Update app.py

app.py

@@ -209,22 +209,33 @@ def extract_text_from_content(content) -> str:
                     tool_content = item.get("content", "")
                     tool_use_id = item.get("tool_use_id", "")
                     # ======================================================
-                    # [إصلاح #3] - ربط نتيجة الأداة بمعرفها tool_use_id
+                    # [إصلاح #2] - تحويل tool_result إلى نص بسيط وواضح
+                    # بدلاً من الصيغة المعقدة، نستخدم نصاً مباشراً يفهمه النموذج
                     # ======================================================
-                    if tool_use_id:
-                        parts.append(f"[Tool Result for {tool_use_id}]:")
                     if isinstance(tool_content, list):
+                        result_texts = []
                         for tc in tool_content:
                             if isinstance(tc, dict) and tc.get("type") == "text":
-                                parts.append(tc.get("text", ""))
+                                result_texts.append(tc.get("text", ""))
                             elif isinstance(tc, str):
-                                parts.append(tc)
+                                result_texts.append(tc)
+                        result_str = "\n".join(result_texts)
                     elif isinstance(tool_content, str):
-                        parts.append(tool_content)
+                        result_str = tool_content
+                    else:
+                        result_str = str(tool_content)
+                    # ======================================================
+                    # [إصلاح #2] - صيغة مبسطة تأمر النموذج بالتنفيذ الفوري
+                    # ======================================================
+                    parts.append(
+                        f"[SYSTEM]: Tool '{tool_use_id}' returned the following data:\n"
+                        f"{result_str}\n"
+                        f"[SYSTEM]: Research results obtained. Now use 'write_file' to save them. "
+                        f"DO NOT explain. Execute immediately."
+                    )
                 elif item.get("type") == "tool_use":
                     tool_name = item.get("name", "unknown")
                     tool_input = item.get("input", {})
-                    # الحفاظ على tool_id لربط الاستجابة لاحقاً
                     tool_id = item.get("id", "")
                     parts.append(
                         f"[Called tool: {tool_name} (id:{tool_id}) "
@@ -248,47 +259,35 @@ class ToolCallParser:
     يدعم أنماطاً متعددة مع regex محسّن يقبل المسافات والأسطر الجديدة.
     """
 
-    # ======================================================
-    # [إصلاح #2] - تحديث الـ Regex ليكون non-greedy
-    # ويقبل المسافات البيضاء والأسطر الجديدة قبل وبعد الوسوم
-    # ======================================================
     PATTERNS = [
-        # النمط 1: <tool_call> مع مسافات مرنة حول الوسم والـ JSON
         re.compile(
             r'\s*<tool_call>\s*(\{.*?\})\s*</tool_call>\s*',
             re.DOTALL | re.IGNORECASE
         ),
-        # النمط 2: ```tool_call أو ```json مع مسافات مرنة
         re.compile(
             r'```(?:tool_call|json)?\s*\n?\s*(\{.*?"(?:name|function)".*?\})\s*\n?\s*```',
             re.DOTALL | re.IGNORECASE
         ),
-        # النمط 3: <function=name>JSON</function>
         re.compile(
             r'\s*<function=(\w+)>\s*(\{.*?\})\s*</function>\s*',
             re.DOTALL | re.IGNORECASE
         ),
-        # النمط 4: [TOOL_CALL]...[/TOOL_CALL]
         re.compile(
             r'\s*\[TOOL_CALL\]\s*(.*?)\s*\[/TOOL_CALL\]\s*',
             re.DOTALL | re.IGNORECASE
         ),
-        # النمط 5: ✿FUNCTION✿
         re.compile(
             r'✿FUNCTION✿:\s*(\w+)\s*\n✿ARGS✿:\s*(\{.*?\})\s*(?:\n✿RESULT✿)?',
             re.DOTALL
         ),
     ]
 
-    # ======================================================
-    # [إصلاح #2] - علامات البداية محدّثة لتشمل المسافات
-    # ======================================================
     START_MARKERS = [
         '<tool_call>',
         '```tool_call',
         '```json',
         '<function=',
-        '[tool_call]',        # نسخة lowercase للمرونة
+        '[tool_call]',
         '[TOOL_CALL]',
         '✿function✿',
         '✿FUNCTION✿',
@@ -303,16 +302,11 @@ class ToolCallParser:
 
     @classmethod
     def might_contain_tool_call(cls, text: str) -> bool:
-        """
-        فحص سريع: هل النص قد يحتوي على بداية tool call؟
-        [إصلاح #2] - يتجاهل حالة الأحرف ويتعامل مع المسافات
-        """
-        # تنظيف النص من المسافات الزائدة ��لفحص
+        """فحص سريع: هل النص قد يحتوي على بداية tool call؟"""
         text_stripped = text.strip().lower()
         for marker in cls.START_MARKERS:
             if marker.lower() in text_stripped:
                 return True
-        # فحص إضافي: هل يبدأ بـ { ويحتوي "name"؟ (JSON مباشر)
         if text_stripped.startswith('{') and '"name"' in text_stripped:
             return True
         return False
@@ -323,10 +317,7 @@ class ToolCallParser:
         text: str,
         available_tools: Optional[List[Dict]] = None
     ) -> Tuple[str, List[Dict]]:
-        """
-        تحليل النص واستخراج tool calls منه.
-        [إصلاح #2] - regex محسّن مع non-greedy matching
-        """
+        """تحليل النص واستخراج tool calls منه."""
         tool_calls = []
         clean_text = text
 
@@ -480,7 +471,6 @@ class ToolCallParser:
             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)
@@ -599,12 +589,12 @@ class ToolCallParser:
 
 
 # =====================================================
-# STREAM TOOL BUFFER - محسّن
+# STREAM TOOL BUFFER - مع إصلاح #4 (إغلاق الوسوم يدوياً)
 # =====================================================
 class StreamToolBuffer:
     """
     Buffer ذكي يجمع chunks الـ stream ويكتشف tool calls.
-    [إصلاح #2] - تحديث _process_text_mode لاكتشاف أفضل
+    [إصلاح #4] - إغلاق الوسوم يدوياً في flush() إذا لم تكتمل
     """
 
     def __init__(self, available_tools: Optional[List[Dict]] = None):
@@ -614,12 +604,15 @@ class StreamToolBuffer:
         self.available_tools = available_tools or []
         self.pending_text = ""
         self.tool_call_depth = 0
+        # ======================================================
+        # [إصلاح #4] - تتبع بداية الوسم لإغلاقه عند الضرورة
+        # ======================================================
+        self._active_start_marker = ""
+        self._active_end_marker = ""
+        self._stream_started_at = time.time()
 
     def feed(self, chunk: str) -> List[Dict]:
-        """
-        إطعام chunk جديد للـ buffer.
-        يُرجع قائمة من الأحداث الجاهزة للإرسال.
-        """
+        """إطعام chunk جديد للـ buffer."""
         events = []
         self.buffer += chunk
 
@@ -637,30 +630,19 @@ class StreamToolBuffer:
         return events
 
     def _process_text_mode(self) -> List[Dict]:
-        """
-        معالجة النص في النمط العادي.
-        [إصلاح #2] - يتجاهل حالة الأحرف ويتعامل مع المسافات قبل الوسوم
-        """
+        """معالجة النص في النمط العادي."""
         events = []
-
-        # ======================================================
-        # [إصلاح #2] البحث بدون حساسية لحالة الأحرف
-        # ======================================================
         buffer_lower = self.buffer.lower()
-
         earliest_pos = -1
         earliest_marker = ""
 
         for marker in ToolCallParser.START_MARKERS:
-            # البحث بدون حساسية لحالة الأحرف
             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 - احتفظ بـ 100 حرف كاحتياط (زيادة من 50)
-            # لأن بعض الوسوم قد تكون أطول
             safe_length = len(self.buffer) - 100
             if safe_length > 0:
                 text_to_send = self.buffer[:safe_length]
@@ -668,34 +650,43 @@ class StreamToolBuffer:
                 if text_to_send:
                     events.append({"type": "text", "text": text_to_send})
         else:
-            # ======================================================
-            # [إصلاح #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:]
             self.in_tool_call = True
             self.tool_call_buffer = ""
+            # ======================================================
+            # [إصلاح #4] - حفظ بداية الوسم النشطة لإغلاقه لاحقاً
+            # ======================================================
+            self._active_start_marker = earliest_marker
+            self._set_active_end_marker(earliest_marker)
 
         return events
 
+    def _set_active_end_marker(self, start_marker: str):
+        """تحديد علامة النهاية المقابلة لعلامة البداية"""
+        start_lower = start_marker.lower()
+        if start_lower == '<tool_call>':
+            self._active_end_marker = '</tool_call>'
+        elif start_lower in ('```tool_call', '```json', '```'):
+            self._active_end_marker = '```'
+        elif start_lower.startswith('<function='):
+            self._active_end_marker = '</function>'
+        elif start_lower in ('[tool_call]', '[tool_call]'):
+            self._active_end_marker = '[/TOOL_CALL]'
+        elif start_lower == '✿function✿':
+            self._active_end_marker = ''
+        else:
+            self._active_end_marker = '</tool_call>'
+
     def _process_tool_call_mode(self) -> List[Dict]:
-        """
-        معالجة النص في نمط tool call.
-        [إصلاح #2] - تحسين اكتشاف نهاية الوسوم مع المسافات
-        """
+        """معالجة النص في نمط tool call."""
         events = []
 
-        # أزواج (نهاية الوسم، بداية الوسم) مع دعم حالة الأحرف
         end_markers_pairs = [
             ('</tool_call>', '<tool_call>'),
             ('```', '```tool_call'),
@@ -712,29 +703,21 @@ class StreamToolBuffer:
             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):]
 
-                # تحليل الـ tool call
                 clean_text, tool_calls = ToolCallParser.parse_tool_calls(
                     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(
@@ -748,11 +731,12 @@ class StreamToolBuffer:
 
                 self.buffer = remaining
                 self.in_tool_call = False
+                self._active_start_marker = ""
+                self._active_end_marker = ""
                 found_end = True
                 break
 
         if not found_end:
-            # لم نجد نهاية - تحقق من الحجم
             if len(self.buffer) > 5000:
                 logger.warning(
                     "[Buffer] Tool call buffer too large without closing tag, "
@@ -761,29 +745,152 @@ class StreamToolBuffer:
                 events.append({"type": "text", "text": self.buffer})
                 self.buffer = ""
                 self.in_tool_call = False
+                self._active_start_marker = ""
+                self._active_end_marker = ""
 
         return events
 
     def flush(self) -> List[Dict]:
-        """تفريغ أي محتوى متبقي في الـ buffer"""
+        """
+        تفريغ أي محتوى متبقي في الـ buffer.
+        ======================================================
+        [إصلاح #4] - إغلاق الوسوم يدوياً إذا بدأت ولم تنتهِ
+        ======================================================
+        """
         events = []
 
         if self.in_tool_call and self.buffer:
+            # ======================================================
+            # [إصلاح #4] الخطوة 1: محاولة إغلاق الوسم يدوياً
+            # إذا اكتشفنا أن الـ stream انقطع قبل إرسال وسم الإغلاق
+            # ======================================================
+            logger.warning(
+                f"[Buffer][Fix#4] Stream ended with unclosed tool_call tag. "
+                f"Active marker: '{self._active_start_marker}'. "
+                f"Attempting manual closure..."
+            )
+
+            # محاولة إضافة وسم الإغلاق المناسب
+            end_marker = self._active_end_marker or "</tool_call>"
+
+            # التحقق إذا كان الـ buffer يحتوي JSON ناقص
+            buffer_with_close = self.buffer + end_marker
+            logger.info(
+                f"[Buffer][Fix#4] Trying to parse with appended '{end_marker}'"
+            )
+
             clean_text, tool_calls = ToolCallParser.parse_tool_calls(
-                self.buffer, self.available_tools
+                buffer_with_close, 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})
+
+            if tool_calls:
+                # نجح الإغلاق اليدوي
+                logger.info(
+                    f"[Buffer][Fix#4] Manual closure SUCCESS: "
+                    f"recovered {len(tool_calls)} tool call(s)"
+                )
+                for tc in tool_calls:
+                    if not tc.get("id"):
+                        tc["id"] = ToolCallParser.generate_tool_id()
+                    events.append(tc)
+                    logger.info(
+                        f"[Buffer][Fix#4] Recovered tool: {tc['name']} "
+                        f"(id: {tc['id']})"
+                    )
+                if clean_text.strip():
+                    events.append({"type": "text", "text": clean_text})
+            else:
+                # ======================================================
+                # [إصلاح #4] الخطوة 2: محاولة إصلاح JSON الناقص
+                # قبل إضافة وسم الإغلاق
+                # ======================================================
+                logger.info(
+                    "[Buffer][Fix#4] Direct closure failed. "
+                    "Attempting JSON repair..."
+                )
+
+                # استخراج JSON من الـ buffer
+                raw_buffer = self.buffer
+                # إزالة علامة البداية إن وجدت
+                if self._active_start_marker:
+                    start_lower = self._active_start_marker.lower()
+                    raw_lower = raw_buffer.lower()
+                    if raw_lower.startswith(start_lower):
+                        raw_buffer = raw_buffer[len(self._active_start_marker):]
+
+                # محاولة إصلاح JSON الناقص
+                json_start = raw_buffer.find('{')
+                if json_start != -1:
+                    json_fragment = raw_buffer[json_start:].strip()
+
+                    # إضافة أقواس مفقودة
+                    open_braces = json_fragment.count('{') - json_fragment.count('}')
+                    if open_braces > 0:
+                        json_fragment += '}' * open_braces
+                        logger.info(
+                            f"[Buffer][Fix#4] Added {open_braces} closing brace(s) "
+                            f"to fix JSON"
+                        )
+
+                    open_brackets = json_fragment.count('[') - json_fragment.count(']')
+                    if open_brackets > 0:
+                        json_fragment += ']' * open_brackets
+
+                    # إضافة وسم الإغلاق بعد إصلاح JSON
+                    repaired_text = (
+                        self._active_start_marker +
+                        json_fragment +
+                        end_marker
+                    )
+
+                    clean_text2, tool_calls2 = ToolCallParser.parse_tool_calls(
+                        repaired_text, self.available_tools
+                    )
+
+                    if tool_calls2:
+                        logger.info(
+                            f"[Buffer][Fix#4] JSON repair SUCCESS: "
+                            f"recovered {len(tool_calls2)} tool call(s)"
+                        )
+                        for tc in tool_calls2:
+                            if not tc.get("id"):
+                                tc["id"] = ToolCallParser.generate_tool_id()
+                            events.append(tc)
+                            logger.info(
+                                f"[Buffer][Fix#4] Repaired tool: {tc['name']} "
+                                f"(id: {tc['id']})"
+                            )
+                        if clean_text2.strip():
+                            events.append({"type": "text", "text": clean_text2})
+                    else:
+                        # فشل كل شيء - إرسال كنص عادي مع تحذير
+                        logger.error(
+                            "[Buffer][Fix#4] All repair attempts failed. "
+                            "Sending as raw text."
+                        )
+                        if self.buffer.strip():
+                            events.append({
+                                "type": "text",
+                                "text": (
+                                    f"[⚠️ Incomplete tool call recovered]\n"
+                                    f"{self.buffer}"
+                                )
+                            })
+                else:
+                    # لا يوجد JSON قابل للاستخراج
+                    if self.buffer.strip():
+                        events.append({"type": "text", "text": self.buffer})
+
         elif self.buffer:
             if self.buffer.strip():
                 events.append({"type": "text", "text": self.buffer})
 
+        # تنظيف الحالة
         self.buffer = ""
         self.in_tool_call = False
+        self._active_start_marker = ""
+        self._active_end_marker = ""
+
         return events
 
 
@@ -883,7 +990,7 @@ class ToolsFormatter:
     def format_tool_result_for_message(tool_use_id: str, content: Any) -> str:
         """
         تحويل نتيجة أداة إلى نص مفهوم للنموذج.
-        [إصلاح #3] - ربط النتيجة بمعرف الأداة tool_use_id
+        [إصلاح #2] - صيغة مبسطة تأمر النموذج بالتنفيذ الفوري
         """
         result_text = ""
         if isinstance(content, str):
@@ -907,19 +1014,18 @@ class ToolsFormatter:
             result_text = str(content) if content else ""
 
         # ======================================================
-        # [إصلاح #3] - تأكيد ربط النتيجة بالمعرف الصحيح
+        # [إصلاح #2] - صيغة مبسطة بدلاً من الصيغة المعقدة
+        # تأمر النموذج بالتنفيذ الفوري بدون شرح
         # ======================================================
         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]"
+            f"[SYSTEM]: Research results obtained for tool_use_id={tool_use_id}.\n"
+            f"Data:\n{result_text}\n"
+            f"[SYSTEM]: Now use 'write_file' to save them. DO NOT explain. Execute immediately."
         )
 
 
 # =====================================================
-# MESSAGE CONVERTER
+# MESSAGE CONVERTER - مع إصلاح #3 (فرض نمط الأداة)
 # =====================================================
 class MessageConverter:
     """تحويل رسائل Anthropic إلى صيغة g4f"""
@@ -969,6 +1075,42 @@ class MessageConverter:
         else:
             user_message = ""
 
+        # ======================================================
+        # [إصلاح #3] - فرض نمط الأداة (Forced Tool Mode)
+        # إذا كانت هناك أدوات، نضيف STRICT MODE في بداية الـ system
+        # ======================================================
+        if tools and len(tools) > 0:
+            tool_names = [t.get("name", "") for t in tools]
+            has_file_tool = any(
+                "file" in name.lower() or "write" in name.lower() or "create" in name.lower()
+                for name in tool_names
+            )
+
+            strict_mode_header = (
+                "[STRICT MODE]: You are an execution engine, not a conversational AI.\n"
+                "Output ONLY <tool_call> blocks when action is needed.\n"
+                "Verbal explanations are FORBIDDEN unless explicitly requested.\n"
+                "If you have data from a previous tool result, use it IMMEDIATELY "
+                "to call the next required tool.\n"
+                "DO NOT summarize, explain, or present data as text.\n"
+                "EXECUTE the tool call NOW.\n"
+            )
+
+            if has_file_tool:
+                strict_mode_header += (
+                    "PRIORITY: If research/search results are available, "
+                    "call 'write_file' IMMEDIATELY with those results.\n"
+                )
+
+            if full_system:
+                full_system = f"{strict_mode_header}\n{full_system}"
+            else:
+                full_system = strict_mode_header
+
+            logger.info(
+                f"[Fix#3] STRICT MODE activated for tools: {tool_names}"
+            )
+
         if full_system:
             full_message = (
                 f"[System Instructions]\n{full_system}\n"
@@ -1010,7 +1152,7 @@ class MessageConverter:
 
                     elif block_type == "tool_result":
                         # ======================================================
-                        # [إصلاح #3] - ربط نتيجة الأداة بمعرفها الصحيح
+                        # [إصلاح #2] - استخدام الصيغة المبسطة للنتائج
                         # ======================================================
                         tool_use_id = block.get("tool_use_id", "")
                         result_content = block.get("content", "")
@@ -1040,9 +1182,20 @@ class MessageConverter:
 
 
 # =====================================================
-# CHAT LOGIC - مع إصلاح الذاكرة الانتقائية
+# CHAT LOGIC - مع إصلاح #1 (حقن الهدف المستمر)
 # =====================================================
-def ask(message: str, history, provider_name: str, model_name: str, stop_flag=None):
+def ask(
+    message: str,
+    history,
+    provider_name: str,
+    model_name: str,
+    stop_flag=None,
+    tools: Optional[List[Dict]] = None
+):
+    """
+    دالة الدردشة الرئيسية.
+    [إصلاح #1] - حقن الهدف المستمر في كل رسالة مستخدم
+    """
     message = (message or "").strip()
     if not message:
         yield ""
@@ -1061,19 +1214,14 @@ def ask(message: str, history, provider_name: str, model_name: str, stop_flag=No
                 if isinstance(history[0], dict):
                     # ======================================================
                     # [إصلاح #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 "
@@ -1092,7 +1240,6 @@ def ask(message: str, history, provider_name: str, model_name: str, stop_flag=No
                             if text:
                                 msgs.append({"role": str(role), "content": text})
                 else:
-                    # صيغة قديمة (list of tuples)
                     if len(history) > 30:
                         smart_history_tuples = history[:5] + history[-25:]
                     else:
@@ -1107,7 +1254,45 @@ def ask(message: str, history, provider_name: str, model_name: str, stop_flag=No
     except Exception as e:
         logger.warning(f"[Memory] History error: {e}")
 
-    msgs.append({"role": "user", "content": message})
+    # ======================================================
+    # [إصلاح #1] - حقن الهدف المستمر (Persistent Goal Injection)
+    # إضافة تذكير بالمهمة الأصلية في كل رسالة مستخدم
+    # ======================================================
+    has_tools = tools and len(tools) > 0
+    has_tool_result_in_history = any(
+        "[SYSTEM]: Research results obtained" in str(item.get("content", ""))
+        for item in msgs
+        if isinstance(item, dict)
+    )
+
+    if has_tools or has_tool_result_in_history:
+        # فحص إذا كانت الرسالة تحتوي على نتائج أداة سابقة
+        if has_tool_result_in_history or "tool result" in message.lower():
+            goal_injection = (
+                "\n\n[RE-ITERATION]: If you have gathered data from a previous tool, "
+                "DO NOT present it as text. "
+                "Use the 'write_file' tool IMMEDIATELY. "
+                "Your primary mission is EXECUTION, not conversation. "
+                "Output ONLY a <tool_call> block."
+            )
+        else:
+            goal_injection = (
+                "\n\n[RE-ITERATION]: Remember your primary mission is EXECUTION. "
+                "If action is needed, use the appropriate tool via <tool_call> block. "
+                "Do not explain what you will do - just DO IT."
+            )
+
+        # إضافة حقن الهدف للرسالة الحالية
+        message_with_injection = message + goal_injection
+        logger.info(
+            f"[Fix#1] Goal injection added to message. "
+            f"Has tools: {has_tools}, "
+            f"Has tool results: {has_tool_result_in_history}"
+        )
+    else:
+        message_with_injection = message
+
+    msgs.append({"role": "user", "content": message_with_injection})
 
     # قائمة المزودات للـ fallback
     fallback_providers = [
@@ -1331,7 +1516,7 @@ async def v1_messages(request: Request):
 
     # Non-stream: تجميع الرد كاملاً
     full_response = ""
-    for chunk in ask(full_message, history, "Blackbox", model):
+    for chunk in ask(full_message, history, "Blackbox", model, tools=tools):
         full_response += chunk
 
     clean_text, tool_calls = ToolCallParser.parse_tool_calls(full_response, tools)
@@ -1348,9 +1533,6 @@ async def v1_messages(request: Request):
             "text": clean_text.strip()
         })
 
-    # ======================================================
-    # [إصلاح #3] - إرسال tool calls مع معرفات صحيحة
-    # ======================================================
     for tc in tool_calls:
         tool_id = tc.get("id") or ToolCallParser.generate_tool_id()
         content_blocks.append({
@@ -1402,7 +1584,6 @@ async def _handle_anthropic_stream(
         message_id = f"msg_{int(time.time())}_{os.urandom(4).hex()}"
         tools_list = tools or []
 
-        # حدث بداية الرسالة
         msg_start = {
             "type": "message_start",
             "message": {
@@ -1431,7 +1612,6 @@ async def _handle_anthropic_stream(
         output_tokens = 0
         has_tool_calls = False
 
-        # ---- دوال مساعدة ----
         def make_text_block_start(index: int) -> str:
             block_start = {
                 "type": "content_block_start",
@@ -1465,14 +1645,8 @@ async def _handle_anthropic_stream(
             )
 
         def make_tool_use_events(index: int, tool_call: Dict) -> str:
-            """
-            إنشاء أحداث tool_use للـ stream.
-            [إصلاح #3] - استخدام المعرف الصحيح من tool_call
-            """
+            """إنشاء أحداث tool_use للـ stream."""
             events_str = ""
-            # ======================================================
-            # [إصلاح #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", {})
@@ -1496,7 +1670,6 @@ async def _handle_anthropic_stream(
                 f"data: {json.dumps(block_start, ensure_ascii=False)}\n\n"
             )
 
-            # إرسال input كـ JSON delta
             input_json = json.dumps(tool_input, ensure_ascii=False)
             chunk_size = 100
             for i in range(0, len(input_json), chunk_size):
@@ -1519,21 +1692,19 @@ async def _handle_anthropic_stream(
 
         # ===== معالجة الـ Stream =====
         try:
-            for chunk in ask(full_message, history, "Blackbox", model):
+            for chunk in ask(full_message, history, "Blackbox", model, tools=tools_list):
                 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
                 events = tool_buffer.feed(chunk)
 
                 for event in events:
@@ -1546,7 +1717,6 @@ 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
@@ -1556,8 +1726,10 @@ async def _handle_anthropic_stream(
                         yield make_tool_use_events(current_block_index, event)
                         current_block_index += 1
 
-            # ===== تفريغ الـ buffer المتبقي =====
+            # ===== تفريغ الـ buffer المتبقي [إصلاح #4] =====
+            logger.info("[Stream] Flushing remaining buffer (Fix#4 active)...")
             remaining_events = tool_buffer.flush()
+
             for event in remaining_events:
                 if event.get("type") == "text":
                     text = event["text"]
@@ -1574,6 +1746,10 @@ async def _handle_anthropic_stream(
                         text_block_open = False
 
                     has_tool_calls = True
+                    logger.info(
+                        f"[Stream][Fix#4] Recovered tool call from flush: "
+                        f"{event.get('name')}"
+                    )
                     yield make_tool_use_events(current_block_index, event)
                     current_block_index += 1
 
@@ -1584,7 +1760,6 @@ async def _handle_anthropic_stream(
                 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:
@@ -1756,11 +1931,12 @@ async def v1_chat_completions(request: Request):
 async def root():
     return {
         "message": "G4F Smart Router - Protocol Translator (Anthropic Compatible)",
-        "version": "2.1.0",
+        "version": "3.0.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"
+            "[Fix #1] Persistent Goal Injection: RE-ITERATION added to every user message",
+            "[Fix #2] Virtual State Flattening: tool_results converted to simple [SYSTEM] text",
+            "[Fix #3] Forced Tool Mode: STRICT MODE header injected when tools are present",
+            "[Fix #4] Stream Tag Auto-Close: flush() repairs unclosed tool_call tags"
         ],
         "providers": list(REAL_PROVIDERS.keys()),
         "endpoints": {
@@ -1774,6 +1950,7 @@ async def root():
             "POST /chat/stream": "Simple stream (AUTH)",
             "GET /providers": "Providers list (AUTH)",
             "GET /debug/test-tool-parse": "Test tool parsing (AUTH)",
+            "POST /debug/test-stream-buffer": "Test stream buffer (AUTH)",
         },
         "cookies": COOKIE_STATUS,
         "status": "✅ Server is working"
@@ -1784,14 +1961,15 @@ async def root():
 async def health():
     return {
         "status": "ok",
-        "version": "2.1.0",
+        "version": "3.0.0",
         "cookies": COOKIE_STATUS,
         "providers": list(REAL_PROVIDERS.keys()),
         "provider_count": len(REAL_PROVIDERS),
         "fixes": {
-            "selective_memory": True,
-            "improved_regex": True,
-            "tool_id_binding": True
+            "persistent_goal_injection": True,
+            "virtual_state_flattening": True,
+            "forced_tool_mode": True,
+            "stream_tag_auto_close": True
         },
         "timestamp": int(time.time())
     }
@@ -1873,6 +2051,14 @@ async def debug_test_tool_parse(request: Request):
                 '</TOOL_CALL>'
             ),
         },
+        {
+            "name": "Unclosed tag (Fix#4 test)",
+            "input": (
+                'Writing file now:\n'
+                '<tool_call>{"name": "write_file", "arguments": {"path": "test.txt", "content": "hello"}'
+                # لا يوجد </tool_call> - هذا يختبر إصلاح #4
+            ),
+        },
         {
             "name": "No tool calls (plain text)",
             "input": "This is just a regular response with no tool calls.",
@@ -1882,6 +2068,18 @@ async def debug_test_tool_parse(request: Request):
     results = []
     for tc in test_cases:
         clean_text, tool_calls = ToolCallParser.parse_tool_calls(tc["input"])
+
+        # اختبار إصلاح #4: محاكاة flush مع وسم غير مكتمل
+        if "Unclosed" in tc["name"]:
+            buf = StreamToolBuffer()
+            buf.feed(tc["input"])
+            flush_events = buf.flush()
+            flush_tool_calls = [e for e in flush_events if e.get("type") != "text"]
+            flush_texts = [e for e in flush_events if e.get("type") == "text"]
+        else:
+            flush_tool_calls = []
+            flush_texts = []
+
         results.append({
             "test_name": tc["name"],
             "input_preview": (
@@ -1892,7 +2090,9 @@ async def debug_test_tool_parse(request: Request):
             "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"])
+            "has_tool_call_marker": ToolCallParser.might_contain_tool_call(tc["input"]),
+            "fix4_flush_recovered": len(flush_tool_calls),
+            "fix4_flush_tool_calls": flush_tool_calls,
         })
 
     return {"test_results": results}
@@ -1932,6 +2132,74 @@ async def debug_test_stream_buffer(request: Request):
     }
 
 
+# =====================================================
+# نقطة تشخيص: اختبار حقن الهدف المستمر
+# =====================================================
+@app.post("/debug/test-goal-injection")
+async def debug_test_goal_injection(request: Request):
+    verify_api_key(request)
+    body = await request.json()
+
+    message = body.get("message", "Create a file with the search results")
+    has_tools = body.get("has_tools", True)
+    has_tool_results = body.get("has_tool_results", True)
+
+    tools_list = [{"name": "write_file"}] if has_tools else []
+    history = []
+
+    if has_tool_results:
+        history = [
+            {
+                "role": "user",
+                "content": "Search for Python tutorials"
+            },
+            {
+                "role": "assistant",
+                "content": (
+                    "[SYSTEM]: Research results obtained for tool_use_id=test123.\n"
+                    "Data:\nPython tutorial results here...\n"
+                    "[SYSTEM]: Now use 'write_file' to save them."
+                )
+            }
+        ]
+
+    # محاكاة ما سيحدث في ask()
+    has_tool_result_in_history = any(
+        "[SYSTEM]: Research results obtained" in str(item.get("content", ""))
+        for item in history
+        if isinstance(item, dict)
+    )
+
+    if has_tools or has_tool_result_in_history:
+        if has_tool_result_in_history or "tool result" in message.lower():
+            goal_injection = (
+                "\n\n[RE-ITERATION]: If you have gathered data from a previous tool, "
+                "DO NOT present it as text. "
+                "Use the 'write_file' tool IMMEDIATELY. "
+                "Your primary mission is EXECUTION, not conversation. "
+                "Output ONLY a <tool_call> block."
+            )
+        else:
+            goal_injection = (
+                "\n\n[RE-ITERATION]: Remember your primary mission is EXECUTION. "
+                "If action is needed, use the appropriate tool via <tool_call> block. "
+                "Do not explain what you will do - just DO IT."
+            )
+        final_message = message + goal_injection
+    else:
+        final_message = message
+        goal_injection = "(none - no tools or tool results detected)"
+
+    return {
+        "original_message": message,
+        "final_message_with_injection": final_message,
+        "injection_added": goal_injection,
+        "has_tools": has_tools,
+        "has_tool_results_in_history": has_tool_result_in_history,
+        "fix1_active": has_tools or has_tool_result_in_history
+    }
+
+
 @app.post("/chat")
 async def chat(request: Request, chat_req: ChatRequest):
     verify_api_key(request)
@@ -2050,9 +2318,12 @@ 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.1 on port {port}")
+    logger.info(f"Starting G4F Smart Router v3.0 on port {port}")
     logger.info(f"Cookies: {COOKIE_STATUS}")
     logger.info(f"Providers: {list(REAL_PROVIDERS.keys())}")
-    logger.info("Fixes: [Memory] [Regex] [Tool-ID-Binding]")
+    logger.info("Fixes Applied:")
+    logger.info("  [Fix#1] Persistent Goal Injection")
+    logger.info("  [Fix#2] Virtual State Flattening")
+    logger.info("  [Fix#3] Forced Tool Mode (STRICT MODE)")
+    logger.info("  [Fix#4] Stream Tag Auto-Close in flush()")
     uvicorn.run("app:app", host="0.0.0.0", port=port, reload=False)
-