Update app.py

app.py

@@ -62,6 +62,140 @@ def load_cookies() -> str:
 
 COOKIE_STATUS = load_cookies()
 
+# =====================================================
+# PERSISTENT CONTEXT STORE
+# يحفظ سياق المهام بين النماذج المختلفة ويمنع النسيان
+# =====================================================
+class PersistentContextStore:
+    """
+    مخزن السياق الدائم - يحفظ:
+    1. المهمة الأصلية (Original Task)
+    2. الخطوات المكتملة (Completed Steps)
+    3. نتائج الأدوات (Tool Results)
+    4. الحالة الحالية (Current State)
+    """
+    def __init__(self):
+        self._store: Dict[str, Dict] = {}
+        self._lock = threading.Lock()
+
+    def get_or_create_session(self, session_id: str) -> Dict:
+        with self._lock:
+            if session_id not in self._store:
+                self._store[session_id] = {
+                    "original_task": "",
+                    "completed_steps": [],
+                    "tool_results": [],
+                    "pending_tool_calls": [],
+                    "current_state": "idle",
+                    "created_at": time.time(),
+                    "last_updated": time.time(),
+                    "message_count": 0,
+                    "provider_history": [],
+                }
+            return self._store[session_id]
+
+    def update_session(self, session_id: str, **kwargs):
+        with self._lock:
+            if session_id not in self._store:
+                self.get_or_create_session(session_id)
+            self._store[session_id].update(kwargs)
+            self._store[session_id]["last_updated"] = time.time()
+
+    def add_tool_result(self, session_id: str, tool_name: str, tool_id: str, result: str):
+        with self._lock:
+            if session_id not in self._store:
+                self.get_or_create_session(session_id)
+            self._store[session_id]["tool_results"].append({
+                "tool_name": tool_name,
+                "tool_id": tool_id,
+                "result": result,
+                "timestamp": time.time()
+            })
+            self._store[session_id]["last_updated"] = time.time()
+
+    def add_completed_step(self, session_id: str, step: str):
+        with self._lock:
+            if session_id not in self._store:
+                self.get_or_create_session(session_id)
+            self._store[session_id]["completed_steps"].append({
+                "step": step,
+                "timestamp": time.time()
+            })
+            self._store[session_id]["last_updated"] = time.time()
+
+    def get_context_summary(self, session_id: str) -> str:
+        """
+        يولّد ملخصاً للسياق يُحقن في كل رسالة
+        هذا هو سر منع النسيان - السياق يُعاد حقنه في كل مرة
+        """
+        with self._lock:
+            if session_id not in self._store:
+                return ""
+            ctx = self._store[session_id]
+
+        parts = []
+
+        if ctx.get("original_task"):
+            parts.append(f"## Original Task\n{ctx['original_task']}")
+
+        if ctx.get("completed_steps"):
+            steps_text = "\n".join(
+                f"  - {s['step']}" for s in ctx["completed_steps"][-10:]
+            )
+            parts.append(f"## Completed Steps\n{steps_text}")
+
+        if ctx.get("tool_results"):
+            # آخر 5 نتائج فقط لتجنب الحجم الكبير
+            recent_results = ctx["tool_results"][-5:]
+            results_text = "\n".join(
+                f"  - [{r['tool_name']}]: {r['result'][:300]}..."
+                if len(r['result']) > 300
+                else f"  - [{r['tool_name']}]: {r['result']}"
+                for r in recent_results
+            )
+            parts.append(f"## Tool Results So Far\n{results_text}")
+
+        if ctx.get("current_state") and ctx["current_state"] != "idle":
+            parts.append(f"## Current State\n{ctx['current_state']}")
+
+        if not parts:
+            return ""
+
+        return "# Task Context (DO NOT FORGET)\n" + "\n\n".join(parts)
+
+    def cleanup_old_sessions(self, max_age_hours: int = 24):
+        """تنظيف الجلسات القديمة"""
+        with self._lock:
+            now = time.time()
+            old_sessions = [
+                sid for sid, data in self._store.items()
+                if now - data.get("last_updated", 0) > max_age_hours * 3600
+            ]
+            for sid in old_sessions:
+                del self._store[sid]
+            if old_sessions:
+                logger.info(f"[Context] Cleaned {len(old_sessions)} old sessions")
+
+    def extract_task_from_messages(self, messages: List[Dict]) -> str:
+        """استخراج المهمة الأصلية من أول رسالة مستخدم"""
+        for msg in messages:
+            if msg.get("role") == "user":
+                content = msg.get("content", "")
+                if isinstance(content, str) and len(content) > 10:
+                    # أ��ل 500 حرف من أول رسالة مستخدم = المهمة الأصلية
+                    return content[:500]
+                elif isinstance(content, list):
+                    for item in content:
+                        if isinstance(item, dict) and item.get("type") == "text":
+                            text = item.get("text", "")
+                            if len(text) > 10:
+                                return text[:500]
+        return ""
+
+
+# المخزن العالمي للسياق
+CONTEXT_STORE = PersistentContextStore()
+
 # =====================================================
 # CACHE محسن
 # =====================================================
@@ -208,10 +342,6 @@ def extract_text_from_content(content) -> str:
                 elif item.get("type") == "tool_result":
                     tool_content = item.get("content", "")
                     tool_use_id = item.get("tool_use_id", "")
-                    # ======================================================
-                    # [إصلاح #2] - تحويل tool_result إلى نص بسيط وواضح
-                    # بدلاً من الصيغة المعقدة، نستخدم نصاً مباشراً يفهمه النموذج
-                    # ======================================================
                     if isinstance(tool_content, list):
                         result_texts = []
                         for tc in tool_content:
@@ -224,22 +354,17 @@ def extract_text_from_content(content) -> str:
                         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."
+                        f"[Tool Result for {tool_use_id}]:\n{result_str}"
                     )
                 elif item.get("type") == "tool_use":
                     tool_name = item.get("name", "unknown")
                     tool_input = item.get("input", {})
                     tool_id = item.get("id", "")
                     parts.append(
-                        f"[Called tool: {tool_name} (id:{tool_id}) "
-                        f"with input: {json.dumps(tool_input, ensure_ascii=False)}]"
+                        f"[Tool Called: {tool_name} (id:{tool_id}) "
+                        f"with: {json.dumps(tool_input, ensure_ascii=False)}]"
                     )
                 elif "text" in item:
                     parts.append(item["text"])
@@ -259,29 +384,6 @@ class ToolCallParser:
     يدعم أنماطاً متعددة مع regex محسّن يقبل المسافات والأسطر الجديدة.
     """
 
-    PATTERNS = [
-        re.compile(
-            r'\s*<tool_call>\s*(\{.*?\})\s*</tool_call>\s*',
-            re.DOTALL | re.IGNORECASE
-        ),
-        re.compile(
-            r'```(?:tool_call|json)?\s*\n?\s*(\{.*?"(?:name|function)".*?\})\s*\n?\s*```',
-            re.DOTALL | re.IGNORECASE
-        ),
-        re.compile(
-            r'\s*<function=(\w+)>\s*(\{.*?\})\s*</function>\s*',
-            re.DOTALL | re.IGNORECASE
-        ),
-        re.compile(
-            r'\s*\[TOOL_CALL\]\s*(.*?)\s*\[/TOOL_CALL\]\s*',
-            re.DOTALL | re.IGNORECASE
-        ),
-        re.compile(
-            r'✿FUNCTION✿:\s*(\w+)\s*\n✿ARGS✿:\s*(\{.*?\})\s*(?:\n✿RESULT✿)?',
-            re.DOTALL
-        ),
-    ]
-
     START_MARKERS = [
         '<tool_call>',
         '```tool_call',
@@ -589,12 +691,11 @@ class ToolCallParser:
 
 
 # =====================================================
-# STREAM TOOL BUFFER - مع إصلاح #4 (إغلاق الوسوم يدوياً)
+# STREAM TOOL BUFFER
 # =====================================================
 class StreamToolBuffer:
     """
     Buffer ذكي يجمع chunks الـ stream ويكتشف tool calls.
-    [إصلاح #4] - إغلاق الوسوم يدوياً في flush() إذا لم تكتمل
     """
 
     def __init__(self, available_tools: Optional[List[Dict]] = None):
@@ -604,9 +705,6 @@ 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()
@@ -659,9 +757,6 @@ class StreamToolBuffer:
             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)
 
@@ -751,96 +846,54 @@ class StreamToolBuffer:
         return events
 
     def flush(self) -> List[Dict]:
-        """
-        تفريغ أي محتوى متبقي في الـ buffer.
-        ======================================================
-        [إصلاح #4] - إغلاق الوسوم يدوياً إذا بدأت ولم تنتهِ
-        ======================================================
-        """
+        """تفريغ أي محتوى متبقي في الـ buffer مع إصلاح الوسوم غير المكتملة."""
         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"[Buffer] 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(
                 buffer_with_close, self.available_tools
             )
 
             if tool_calls:
-                # نجح الإغلاق اليدوي
                 logger.info(
-                    f"[Buffer][Fix#4] Manual closure SUCCESS: "
-                    f"recovered {len(tool_calls)} tool call(s)"
+                    f"[Buffer] Manual closure SUCCESS: 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
+                # محاولة إصلاح JSON الناقص
                 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
+                        self._active_start_marker + json_fragment + end_marker
                     )
 
                     clean_text2, tool_calls2 = ToolCallParser.parse_tool_calls(
@@ -848,36 +901,16 @@ class StreamToolBuffer:
                     )
 
                     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}"
-                                )
-                            })
+                            events.append({"type": "text", "text": self.buffer})
                 else:
-                    # لا يوجد JSON قابل للاستخراج
                     if self.buffer.strip():
                         events.append({"type": "text", "text": self.buffer})
 
@@ -885,7 +918,6 @@ class StreamToolBuffer:
             if self.buffer.strip():
                 events.append({"type": "text", "text": self.buffer})
 
-        # تنظيف الحالة
         self.buffer = ""
         self.in_tool_call = False
         self._active_start_marker = ""
@@ -895,38 +927,32 @@ class StreamToolBuffer:
 
 
 # =====================================================
-# TOOLS FORMATTER
+# TOOLS FORMATTER - نسخة متوازنة (لا تشدد مفرط)
 # =====================================================
 class ToolsFormatter:
-    """تحويل أدوات Anthropic إلى نص للنموذج"""
+    """تحويل أدوات Anthropic إلى نص للنموذج - صيغة متوازنة"""
 
     @staticmethod
     def format_tools_for_prompt(tools: List[Dict], tool_choice: Any = None) -> str:
+        """
+        تنسيق الأدوات بصيغة واضحة دون ضغط مفرط.
+        الضغط المفرط كان سبب تجاهل النموذج للأوامر.
+        """
         if not tools:
             return ""
 
         lines = []
         lines.append("# Available Tools")
         lines.append("")
-        lines.append(
-            "You have access to the following tools. "
-            "To use a tool, respond with a tool_call block."
-        )
-        lines.append(
-            "IMPORTANT: When you need to use a tool, you MUST format "
-            "your response EXACTLY like this:"
-        )
+        lines.append("You have access to the following tools.")
+        lines.append("When you need to use a tool, format your response like this:")
         lines.append("")
         lines.append("<tool_call>")
         lines.append('{"name": "tool_name", "arguments": {"param1": "value1"}}')
         lines.append("</tool_call>")
         lines.append("")
-        lines.append(
-            "You can include text explanation before and/or after the tool_call block."
-        )
-        lines.append(
-            "You can make multiple tool calls by using multiple <tool_call> blocks."
-        )
+        lines.append("You can include text before or after the tool_call block.")
+        lines.append("You can make multiple tool calls using multiple <tool_call> blocks.")
         lines.append("")
         lines.append("## Tool Definitions:")
         lines.append("")
@@ -962,36 +988,29 @@ class ToolsFormatter:
 
             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."
+                            f"**Note:** Please use the `{forced_tool}` tool for this request."
                         )
                 elif tool_choice.get("type") == "any":
                     lines.append(
-                        "**IMPORTANT:** You MUST use at least one tool."
+                        "**Note:** Please use at least one tool to complete this request."
                     )
-            elif tool_choice == "auto":
-                lines.append("Use tools when appropriate.")
             elif tool_choice == "any":
-                lines.append("**IMPORTANT:** You MUST use at least one tool.")
+                lines.append("**Note:** Please use at least one tool.")
 
         lines.append("")
-        lines.append("Remember: Always use <tool_call>JSON</tool_call> format.")
-        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:
-        """
-        تحويل نتيجة أداة إلى نص مفهوم للنموذج.
-        [إصلاح #2] - صيغة مبسطة تأمر النموذج بالتنفيذ الفوري
-        """
+        """تحويل نتيجة أداة إلى نص مفهوم للنموذج."""
         result_text = ""
         if isinstance(content, str):
             result_text = content
@@ -1013,37 +1032,39 @@ class ToolsFormatter:
         else:
             result_text = str(content) if content else ""
 
-        # ======================================================
-        # [إصلاح #2] - صيغة مبسطة بدلاً من الصيغة المعقدة
-        # تأمر النموذج بالتنفيذ الفوري بدون شرح
-        # ======================================================
         return (
-            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."
+            f"[Tool Result - ID: {tool_use_id}]\n"
+            f"{result_text}\n"
+            f"[End Tool Result]"
         )
 
 
 # =====================================================
-# MESSAGE CONVERTER - مع إصلاح #3 (فرض نمط الأداة)
+# MESSAGE CONVERTER - محسّن للحفاظ على السياق الكامل
 # =====================================================
 class MessageConverter:
-    """تحويل رسائل Anthropic إلى صيغة g4f"""
+    """
+    تحويل رسائل Anthropic إلى صيغة g4f مع الحفاظ الكامل على السياق.
+    
+    الإصلاح الجوهري: لا نحذف أي رسائل من التاريخ إلا عند الضرورة القصوى،
+    والسياق يُحفظ في PersistentContextStore ويُحقن في كل طلب.
+    """
 
     @staticmethod
     def convert_messages(
         messages: List[Dict],
         system_prompt: str = "",
         tools: Optional[List[Dict]] = None,
-        tool_choice: Any = None
+        tool_choice: Any = None,
+        session_id: str = ""
     ) -> Tuple[str, List[Dict]]:
         """تحويل رسائل Anthropic إلى (full_message, history) لـ g4f"""
         history = []
 
-        full_system = ""
-        if system_prompt:
-            full_system = system_prompt
+        # بناء system prompt
+        full_system = system_prompt if system_prompt else ""
 
+        # إضافة تعريف الأدوات إذا وجدت
         if tools:
             tools_text = ToolsFormatter.format_tools_for_prompt(tools, tool_choice)
             if full_system:
@@ -1051,6 +1072,19 @@ class MessageConverter:
             else:
                 full_system = tools_text
 
+        # حقن سياق المهمة المحفوظ (منع النسيان عند تبديل النماذج)
+        if session_id:
+            context_summary = CONTEXT_STORE.get_context_summary(session_id)
+            if context_summary:
+                if full_system:
+                    full_system = f"{full_system}\n\n{context_summary}"
+                else:
+                    full_system = context_summary
+                logger.info(
+                    f"[Context] Injected persistent context for session {session_id[:8]}..."
+                )
+
+        # معالجة الرسائل وبناء التاريخ
         for msg in messages:
             role = msg.get("role", "user")
             content = msg.get("content", "")
@@ -1069,48 +1103,14 @@ class MessageConverter:
                 g4f_role = "user" if role == "user" else "assistant"
                 history.append({"role": g4f_role, "content": converted_text})
 
+        # استخراج الرسالة الأخيرة
         if history:
             last_msg = history.pop()
             user_message = last_msg["content"]
         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}"
-            )
-
+        # بناء الرسالة الكاملة مع system prompt
         if full_system:
             full_message = (
                 f"[System Instructions]\n{full_system}\n"
@@ -1123,7 +1123,7 @@ class MessageConverter:
 
     @staticmethod
     def _convert_content(content: Any, role: str) -> str:
-        """تحويل محتوى رسالة واحدة"""
+        """تحويل محتوى رسالة واحدة مع الحفاظ على كل المعلومات"""
         if isinstance(content, str):
             return content
 
@@ -1151,9 +1151,6 @@ class MessageConverter:
                         )
 
                     elif block_type == "tool_result":
-                        # ======================================================
-                        # [إصلاح #2] - استخدام الصيغة المبسطة للنتائج
-                        # ======================================================
                         tool_use_id = block.get("tool_use_id", "")
                         result_content = block.get("content", "")
                         is_error = block.get("is_error", False)
@@ -1182,52 +1179,160 @@ class MessageConverter:
 
 
 # =====================================================
-# CHAT LOGIC - مع إصلاح #1 (حقن الهدف المستمر)
+# SMART HISTORY MANAGER
+# يدير التاريخ بذكاء للحفاظ على السياق الكامل
+# =====================================================
+class SmartHistoryManager:
+    """
+    مدير التاريخ الذكي - يحل مشكلة النسيان بشكل نهائي.
+    
+    الاستراتيجية:
+    1. يحتفظ دائماً بأول N رسالة (تحتوي المهمة الأصلية)
+    2. يحتفظ دائماً بآخر M رسالة (السياق الحالي)
+    3. يضغط الرسائل الوسطى بدلاً من حذفها
+    4. يستخرج ويحفظ نتائج الأدوات في PersistentContextStore
+    """
+
+    FIRST_MESSAGES_TO_KEEP = 5   # أول 5 رسائل (المهمة الأصلية)
+    LAST_MESSAGES_TO_KEEP = 20   # آخر 20 رسالة (السياق الحالي)
+    MAX_TOTAL_MESSAGES = 30      # الحد الأقصى الإجمالي
+
+    @classmethod
+    def process_history(
+        cls,
+        history: List[Dict],
+        session_id: str = ""
+    ) -> List[Dict]:
+        """
+        معالجة التاريخ بذكاء مع استخراج وحفظ المعلومات المهمة.
+        """
+        if not history:
+            return []
+
+        # استخراج نتائج الأدوات وحفظها في المخزن الدائم
+        if session_id:
+            cls._extract_and_store_tool_results(history, session_id)
+
+        total = len(history)
+
+        # إذا كان التاريخ صغيراً، نحتفظ بكله
+        if total <= cls.MAX_TOTAL_MESSAGES:
+            logger.info(f"[History] Full history: {total} messages (under limit)")
+            return history
+
+        # التاريخ كبير: نطبق الاستراتيجية الذكية
+        first_part = history[:cls.FIRST_MESSAGES_TO_KEEP]
+        last_part = history[-cls.LAST_MESSAGES_TO_KEEP:]
+
+        # إنشاء ملخص للجزء الوسط
+        middle_part = history[cls.FIRST_MESSAGES_TO_KEEP:-cls.LAST_MESSAGES_TO_KEEP]
+        if middle_part:
+            summary = cls._summarize_middle(middle_part)
+            if summary:
+                summary_msg = {
+                    "role": "assistant",
+                    "content": f"[Context Summary - {len(middle_part)} messages compressed]\n{summary}"
+                }
+                smart_history = first_part + [summary_msg] + last_part
+            else:
+                smart_history = first_part + last_part
+        else:
+            smart_history = first_part + last_part
+
+        logger.info(
+            f"[History] Smart compression: {total} → {len(smart_history)} messages "
+            f"(kept first {cls.FIRST_MESSAGES_TO_KEEP} + last {cls.LAST_MESSAGES_TO_KEEP})"
+        )
+
+        return smart_history
+
+    @classmethod
+    def _extract_and_store_tool_results(
+        cls,
+        history: List[Dict],
+        session_id: str
+    ):
+        """استخراج نتائج الأدوات من التاريخ وحفظها في المخزن الدائم"""
+        for msg in history:
+            content = msg.get("content", "")
+            if isinstance(content, str):
+                # البحث عن نتائج الأدوات في النص
+                if "[Tool Result" in content or "[SYSTEM]: Research results" in content:
+                    # استخراج اسم الأداة والنتيجة
+                    tool_match = re.search(
+                        r'\[Tool Result - ID: ([^\]]+)\]\n(.*?)\n\[End Tool Result\]',
+                        content,
+                        re.DOTALL
+                    )
+                    if tool_match:
+                        tool_id = tool_match.group(1)
+                        result = tool_match.group(2)[:500]  # أول 500 حرف
+                        CONTEXT_STORE.add_tool_result(
+                            session_id, "tool", tool_id, result
+                        )
+
+    @classmethod
+    def _summarize_middle(cls, messages: List[Dict]) -> str:
+        """إنشاء ملخص نصي للرسائل الوسطى"""
+        if not messages:
+            return ""
+
+        summary_parts = []
+        for msg in messages:
+            role = msg.get("role", "")
+            content = str(msg.get("content", ""))[:200]  # أول 200 حرف
+            summary_parts.append(f"[{role}]: {content}...")
+
+        return "\n".join(summary_parts[:10])  # أول 10 رسائل من الملخص
+
+
+# =====================================================
+# CHAT LOGIC - الإصلاح الجوهري
 # =====================================================
 def ask(
     message: str,
-    history,
+    history: List,
     provider_name: str,
     model_name: str,
     stop_flag=None,
-    tools: Optional[List[Dict]] = None
+    tools: Optional[List[Dict]] = None,
+    session_id: str = ""
 ):
     """
-    دالة الدردشة الرئيسية.
-    [إصلاح #1] - حقن الهدف المستمر في كل رسالة مستخدم
+    دالة الدردشة الرئيسية - مُصلحة بشكل جوهري.
+    
+    الإصلاحات:
+    1. لا STRICT MODE مفرط - فقط تعليمات واضحة ومعقولة
+    2. حفظ السياق في PersistentContextStore
+    3. SmartHistoryManager يدير التاريخ بذكاء
+    4. Fallback يبدأ من المزود المطلوب فعلاً
+    5. لا حقن هدف مفرط يربك النموذج
     """
     message = (message or "").strip()
     if not message:
         yield ""
         return
 
-    key = f"{provider_name}|{model_name}|{message[:200]}"
-    cached = CACHE.get(key)
-    if cached:
-        yield cached
-        return
+    # لا نستخدم الكاش عند وجود أدوات لأن الأدوات تتطلب استجابة جديدة دائماً
+    if not tools:
+        key = f"{provider_name}|{model_name}|{message[:200]}"
+        cached = CACHE.get(key)
+        if cached:
+            yield cached
+            return
+    else:
+        key = None
 
+    # معالجة التاريخ بذكاء
     msgs = []
     try:
         if history:
             if isinstance(history, list) and len(history) > 0:
                 if isinstance(history[0], dict):
-                    # ======================================================
-                    # [إصلاح #1] - الذاكرة الانتقائية (Selective History)
-                    # ======================================================
-                    if len(history) > 60:
-                        smart_history = history[:10] + history[-50:]
-                        logger.info(
-                            f"[Memory] Smart history: keeping first 10 + "
-                            f"last 50 from {len(history)} total messages"
-                        )
-                    else:
-                        smart_history = history
-                        logger.info(
-                            f"[Memory] Full history: {len(history)} messages "
-                            f"(under threshold)"
-                        )
-
+                    # استخدام SmartHistoryManager
+                    smart_history = SmartHistoryManager.process_history(
+                        history, session_id
+                    )
                     for item in smart_history:
                         role = item.get("role")
                         content = item.get("content")
@@ -1240,6 +1345,7 @@ def ask(
                             if text:
                                 msgs.append({"role": str(role), "content": text})
                 else:
+                    # تنسيق tuples القديم
                     if len(history) > 30:
                         smart_history_tuples = history[:5] + history[-25:]
                     else:
@@ -1252,59 +1358,34 @@ def ask(
                             if item[1]:
                                 msgs.append({"role": "assistant", "content": str(item[1])})
     except Exception as e:
-        logger.warning(f"[Memory] History error: {e}")
-
-    # ======================================================
-    # [إصلاح #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."
+        logger.warning(f"[History] Error processing history: {e}")
+
+    # إضافة الرسالة الحالية
+    msgs.append({"role": "user", "content": message})
+
+    # تحديث المخزن الدائم
+    if session_id:
+        ctx = CONTEXT_STORE.get_or_create_session(session_id)
+        # حفظ المهمة الأصلية إذا لم تُحفظ بعد
+        if not ctx.get("original_task") and len(msgs) <= 2:
+            CONTEXT_STORE.update_session(
+                session_id,
+                original_task=message[:500],
+                current_state="processing"
             )
-        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}"
-        )
+        ctx["message_count"] = ctx.get("message_count", 0) + 1
+
+    # قائمة المزودين للـ fallback - يبدأ من المزود المطلوب
+    all_provider_names = list(REAL_PROVIDERS.keys())
+    
+    # ترتيب المزودين: المطلوب أولاً، ثم الباقين
+    if provider_name in all_provider_names:
+        fallback_providers = [provider_name] + [
+            p for p in all_provider_names if p != provider_name
+        ]
     else:
-        message_with_injection = message
-
-    msgs.append({"role": "user", "content": message_with_injection})
-
-    # قائمة المزودات للـ fallback
-    fallback_providers = [
-        provider_name,
-        "Blackbox",
-        "DeepSeek",
-        "Perplexity",
-        "Copilot",
-        "You",
-        "Bing",
-        "Qwen"
-    ]
+        fallback_providers = all_provider_names
+
     used = []
 
     for pname in fallback_providers:
@@ -1321,34 +1402,64 @@ def ask(
             logger.warning(f"[Fallback] No models for provider {pname}")
             continue
 
+        # ترتيب النماذج: المطلوب أولاً
         if model_name in models_list:
             model_candidates = [model_name] + [m for m in models_list if m != model_name]
         else:
             model_candidates = models_list
 
-        for m in model_candidates[:10]:
+        for m in model_candidates[:5]:
             try:
                 logger.info(f"[Fallback] Trying provider {pname} with model {m}")
+
+                # تسجيل المزود المستخدم في المخزن الدائم
+                if session_id:
+                    CONTEXT_STORE.get_or_create_session(session_id)
+                    provider_history = CONTEXT_STORE._store[session_id].get(
+                        "provider_history", []
+                    )
+                    provider_history.append({
+                        "provider": pname,
+                        "model": m,
+                        "timestamp": time.time()
+                    })
+                    # الاحتفاظ بآخر 20 مزود فقط
+                    CONTEXT_STORE._store[session_id]["provider_history"] = (
+                        provider_history[-20:]
+                    )
+
                 stream = g4f.ChatCompletion.create(
                     model=m,
                     provider=pobj,
                     messages=msgs,
                     stream=True,
-                    timeout=45
+                    timeout=60
                 )
                 buffer = []
+                got_response = False
                 for chunk in stream:
                     if stop_flag and stop_flag.is_set():
                         return
                     c = clean_stream(chunk)
                     if not c:
                         continue
+                    got_response = True
                     buffer.append(c)
                     yield c
+
                 full = "".join(buffer)
-                if full.strip():
-                    CACHE.set(key, full)
+                if full.strip() and got_response:
+                    # حفظ في الكاش فقط إذا لم تكن هناك أدوات
+                    if key:
+                        CACHE.set(key, full)
+                    # تحديث حالة الجلسة
+                    if session_id:
+                        CONTEXT_STORE.update_session(
+                            session_id,
+                            current_state="completed_step"
+                        )
                     return
+
             except Exception as e:
                 logger.warning(
                     f"[Fallback] Provider {pname} model {m} failed: {str(e)[:200]}"
@@ -1358,12 +1469,60 @@ def ask(
     yield "❌ فشلت جميع المزودات. تأكد من اتصال الإنترنت أو حاول لاحقاً."
 
 
+# =====================================================
+# SESSION ID EXTRACTOR
+# استخراج معرف الجلسة من الطلب
+# =====================================================
+def extract_session_id(request: Request, body: Dict) -> str:
+    """
+    استخراج أو توليد معرف جلسة فريد.
+    يستخدم لربط الطلبات المتعددة بنفس المحادثة.
+    """
+    # محاولة استخراج من الـ headers
+    session_id = (
+        request.headers.get("X-Session-ID", "") or
+        request.headers.get("x-session-id", "") or
+        request.headers.get("X-Conversation-ID", "") or
+        ""
+    )
+
+    if session_id:
+        return session_id
+
+    # محاولة استخراج من الـ metadata
+    metadata = body.get("metadata", {})
+    if isinstance(metadata, dict):
+        session_id = (
+            metadata.get("session_id", "") or
+            metadata.get("conversation_id", "") or
+            metadata.get("user_id", "") or
+            ""
+        )
+
+    if session_id:
+        return session_id
+
+    # توليد معرف من محتوى الرسائل (ثابت لنفس المحادثة)
+    messages = body.get("messages", [])
+    if messages:
+        # استخدام أول رسالة لتوليد معرف ثابت
+        first_msg = messages[0]
+        content = str(first_msg.get("content", ""))[:100]
+        # معرف شبه ثابت بناءً على المحتوى
+        import hashlib
+        hash_val = hashlib.md5(content.encode()).hexdigest()[:16]
+        return f"auto_{hash_val}"
+
+    # توليد معرف عشوائي كحل أخير
+    return f"rand_{uuid.uuid4().hex[:16]}"
+
+
 # =====================================================
 # FASTAPI
 # =====================================================
 app = FastAPI(
     title="G4F Smart Router",
-    description="AI Gateway - Protocol Translator for Anthropic"
+    description="AI Gateway - Protocol Translator for Anthropic (Fixed Version)"
 )
 
 app.add_middleware(
@@ -1382,6 +1541,7 @@ class ChatRequest(BaseModel):
     provider: str = "Blackbox"
     model: str = "gpt-4o"
     history: List[Any] = []
+    session_id: str = ""
 
 
 # =====================================================
@@ -1471,10 +1631,14 @@ async def v1_messages(request: Request):
     verify_api_key(request)
     body = await request.json()
 
+    # استخراج معرف الجلسة
+    session_id = extract_session_id(request, body)
+
     logger.info(
         f"[API] /v1/messages - model={body.get('model')}, "
         f"stream={body.get('stream')}, "
-        f"tools_count={len(body.get('tools', []))}"
+        f"tools_count={len(body.get('tools', []))}, "
+        f"session={session_id[:8]}..."
     )
 
     messages = body.get("messages", [])
@@ -1499,8 +1663,23 @@ async def v1_messages(request: Request):
     tool_choice = body.get("tool_choice", "auto")
     metadata = body.get("metadata", {})
 
+    # استخراج المهمة الأصلية وحفظها
+    ctx = CONTEXT_STORE.get_or_create_session(session_id)
+    if not ctx.get("original_task"):
+        original_task = CONTEXT_STORE.extract_task_from_messages(messages)
+        if original_task:
+            CONTEXT_STORE.update_session(
+                session_id,
+                original_task=original_task
+            )
+            logger.info(
+                f"[Context] Stored original task for session {session_id[:8]}: "
+                f"{original_task[:50]}..."
+            )
+
+    # تحويل الرسائل مع حقن السياق
     full_message, history = MessageConverter.convert_messages(
-        messages, system_prompt, tools, tool_choice
+        messages, system_prompt, tools, tool_choice, session_id
     )
 
     logger.info(
@@ -1511,12 +1690,16 @@ async def v1_messages(request: Request):
 
     if is_stream:
         return await _handle_anthropic_stream(
-            full_message, history, model, max_tokens, tools, tool_choice, metadata
+            full_message, history, model, max_tokens, tools, tool_choice,
+            metadata, session_id
         )
 
     # Non-stream: تجميع الرد كاملاً
     full_response = ""
-    for chunk in ask(full_message, history, "Blackbox", model, tools=tools):
+    for chunk in ask(
+        full_message, history, "Blackbox", model,
+        tools=tools, session_id=session_id
+    ):
         full_response += chunk
 
     clean_text, tool_calls = ToolCallParser.parse_tool_calls(full_response, tools)
@@ -1544,6 +1727,12 @@ async def v1_messages(request: Request):
         logger.info(
             f"[API] Tool call in response: {tc['name']} (id: {tool_id})"
         )
+        # حفظ خطوة الأداة في المخزن الدائم
+        if session_id:
+            CONTEXT_STORE.add_completed_step(
+                session_id,
+                f"Called tool: {tc['name']} with {json.dumps(tc.get('input', {}))[:100]}"
+            )
 
     if not content_blocks:
         content_blocks.append({
@@ -1578,7 +1767,8 @@ async def _handle_anthropic_stream(
     max_tokens: int,
     tools: List[Dict] = None,
     tool_choice: Any = None,
-    metadata: Dict = None
+    metadata: Dict = None,
+    session_id: str = ""
 ):
     async def generate_stream():
         message_id = f"msg_{int(time.time())}_{os.urandom(4).hex()}"
@@ -1611,6 +1801,7 @@ async def _handle_anthropic_stream(
         text_block_open = False
         output_tokens = 0
         has_tool_calls = False
+        detected_tool_calls = []
 
         def make_text_block_start(index: int) -> str:
             block_start = {
@@ -1692,19 +1883,24 @@ async def _handle_anthropic_stream(
 
         # ===== معالجة الـ Stream =====
         try:
-            for chunk in ask(full_message, history, "Blackbox", model, tools=tools_list):
+            for chunk in ask(
+                full_message, history, "Blackbox", model,
+                tools=tools_list, session_id=session_id
+            ):
                 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:
@@ -1723,11 +1919,12 @@ async def _handle_anthropic_stream(
                             text_block_open = False
 
                         has_tool_calls = True
+                        detected_tool_calls.append(event)
                         yield make_tool_use_events(current_block_index, event)
                         current_block_index += 1
 
-            # ===== تفريغ الـ buffer المتبقي [إصلاح #4] =====
-            logger.info("[Stream] Flushing remaining buffer (Fix#4 active)...")
+            # ===== تفريغ الـ buffer المتبقي =====
+            logger.info("[Stream] Flushing remaining buffer...")
             remaining_events = tool_buffer.flush()
 
             for event in remaining_events:
@@ -1746,8 +1943,9 @@ async def _handle_anthropic_stream(
                         text_block_open = False
 
                     has_tool_calls = True
+                    detected_tool_calls.append(event)
                     logger.info(
-                        f"[Stream][Fix#4] Recovered tool call from flush: "
+                        f"[Stream] Recovered tool call from flush: "
                         f"{event.get('name')}"
                     )
                     yield make_tool_use_events(current_block_index, event)
@@ -1760,6 +1958,7 @@ async def _handle_anthropic_stream(
                 text_block_open = True
             yield make_text_delta(current_block_index, f"\n\n[Error: {str(e)}]")
 
+        # إغلاق الـ blocks المفتوحة
         if text_block_open:
             yield make_block_stop(current_block_index)
         elif current_block_index == 0 and not has_tool_calls:
@@ -1767,6 +1966,15 @@ async def _handle_anthropic_stream(
             yield make_text_delta(0, "")
             yield make_block_stop(0)
 
+        # حفظ الأدوات المكتشفة في المخزن الدائم
+        if session_id and detected_tool_calls:
+            for tc in detected_tool_calls:
+                CONTEXT_STORE.add_completed_step(
+                    session_id,
+                    f"Called tool: {tc.get('name', 'unknown')} "
+                    f"with {json.dumps(tc.get('input', {}))[:100]}"
+                )
+
         stop_reason = "tool_use" if has_tool_calls else "end_turn"
 
         msg_delta = {
@@ -1803,6 +2011,8 @@ async def v1_messages_stream(request: Request):
     verify_api_key(request)
     body = await request.json()
 
+    session_id = extract_session_id(request, body)
+
     messages = body.get("messages", [])
     if not messages:
         raise HTTPException(status_code=400, detail="No messages provided")
@@ -1823,11 +2033,12 @@ async def v1_messages_stream(request: Request):
     tool_choice = body.get("tool_choice", "auto")
 
     full_message, history = MessageConverter.convert_messages(
-        messages, system_prompt, tools, tool_choice
+        messages, system_prompt, tools, tool_choice, session_id
     )
 
     return await _handle_anthropic_stream(
-        full_message, history, model, max_tokens, tools, tool_choice
+        full_message, history, model, max_tokens, tools, tool_choice,
+        {}, session_id
     )
 
 
@@ -1839,6 +2050,8 @@ async def v1_chat_completions(request: Request):
     verify_api_key(request)
     body = await request.json()
 
+    session_id = extract_session_id(request, body)
+
     messages = body.get("messages", [])
     if not messages:
         raise HTTPException(status_code=400, detail="No messages provided")
@@ -1856,11 +2069,16 @@ async def v1_chat_completions(request: Request):
         if role and content:
             history.append({"role": role, "content": content})
 
+    # تطبيق SmartHistoryManager
+    history = SmartHistoryManager.process_history(history, session_id)
+
     completion_id = f"chatcmpl-{int(time.time())}_{os.urandom(4).hex()}"
 
     if is_stream:
         async def openai_stream():
-            for chunk in ask(user_message, history, "Blackbox", model):
+            for chunk in ask(
+                user_message, history, "Blackbox", model, session_id=session_id
+            ):
                 if chunk:
                     data = {
                         "id": completion_id,
@@ -1900,7 +2118,9 @@ async def v1_chat_completions(request: Request):
         )
 
     full_response = ""
-    for chunk in ask(user_message, history, "Blackbox", model):
+    for chunk in ask(
+        user_message, history, "Blackbox", model, session_id=session_id
+    ):
         full_response += chunk
 
     return {
@@ -1930,13 +2150,17 @@ async def v1_chat_completions(request: Request):
 @app.get("/")
 async def root():
     return {
-        "message": "G4F Smart Router - Protocol Translator (Anthropic Compatible)",
-        "version": "3.0.0",
+        "message": "G4F Smart Router - Fixed Version",
+        "version": "4.0.0",
         "fixes_applied": [
-            "[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"
+            "Removed STRICT MODE (was causing model to ignore all commands)",
+            "Added PersistentContextStore (prevents forgetting between model switches)",
+            "Added SmartHistoryManager (intelligent history compression)",
+            "Fixed Fallback order (starts from requested provider, not always Blackbox)",
+            "Balanced tool instructions (clear but not aggressive)",
+            "Added session_id support for context persistence",
+            "Removed excessive goal injection (was confusing the model)",
+            "Stream tag auto-close preserved from v3"
         ],
         "providers": list(REAL_PROVIDERS.keys()),
         "endpoints": {
@@ -1949,8 +2173,8 @@ async def root():
             "POST /chat": "Simple chat (AUTH)",
             "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)",
+            "GET /context/{session_id}": "View session context (AUTH)",
+            "DELETE /context/{session_id}": "Clear session context (AUTH)",
         },
         "cookies": COOKIE_STATUS,
         "status": "✅ Server is working"
@@ -1961,15 +2185,20 @@ async def root():
 async def health():
     return {
         "status": "ok",
-        "version": "3.0.0",
+        "version": "4.0.0",
         "cookies": COOKIE_STATUS,
         "providers": list(REAL_PROVIDERS.keys()),
         "provider_count": len(REAL_PROVIDERS),
+        "context_store": {
+            "active_sessions": len(CONTEXT_STORE._store),
+        },
         "fixes": {
-            "persistent_goal_injection": True,
-            "virtual_state_flattening": True,
-            "forced_tool_mode": True,
-            "stream_tag_auto_close": True
+            "persistent_context_store": True,
+            "smart_history_manager": True,
+            "balanced_tool_instructions": True,
+            "correct_fallback_order": True,
+            "stream_tag_auto_close": True,
+            "removed_strict_mode": True,
         },
         "timestamp": int(time.time())
     }
@@ -1988,6 +2217,52 @@ async def get_providers(request: Request):
     return {"providers": result}
 
 
+# =====================================================
+# نقطة عرض سياق الجلسة
+# =====================================================
+@app.get("/context/{session_id}")
+async def get_session_context(session_id: str, request: Request):
+    """عرض سياق جلسة محددة - مفيد للتشخيص"""
+    verify_api_key(request)
+    ctx = CONTEXT_STORE.get_or_create_session(session_id)
+    return {
+        "session_id": session_id,
+        "context": ctx,
+        "summary": CONTEXT_STORE.get_context_summary(session_id)
+    }
+
+
+@app.delete("/context/{session_id}")
+async def clear_session_context(session_id: str, request: Request):
+    """مسح سياق جلسة محددة"""
+    verify_api_key(request)
+    with CONTEXT_STORE._lock:
+        if session_id in CONTEXT_STORE._store:
+            del CONTEXT_STORE._store[session_id]
+            return {"message": f"Session {session_id} cleared"}
+    return {"message": f"Session {session_id} not found"}
+
+
+@app.get("/context")
+async def list_sessions(request: Request):
+    """عرض قائمة الجلسات النشطة"""
+    verify_api_key(request)
+    sessions = []
+    with CONTEXT_STORE._lock:
+        for sid, ctx in CONTEXT_STORE._store.items():
+            sessions.append({
+                "session_id": sid,
+                "message_count": ctx.get("message_count", 0),
+                "original_task_preview": ctx.get("original_task", "")[:100],
+                "current_state": ctx.get("current_state", "idle"),
+                "completed_steps": len(ctx.get("completed_steps", [])),
+                "tool_results": len(ctx.get("tool_results", [])),
+                "last_updated": ctx.get("last_updated", 0),
+                "provider_count": len(ctx.get("provider_history", [])),
+            })
+    return {"sessions": sessions, "total": len(sessions)}
+
+
 # =====================================================
 # نقطة تشخيص: اختبار تحليل tool calls
 # =====================================================
@@ -2043,22 +2318,6 @@ async def debug_test_tool_parse(request: Request):
                 '</tool_call>'
             ),
         },
-        {
-            "name": "Case insensitive detection",
-            "input": (
-                'Using uppercase:\n'
-                '<TOOL_CALL>{"name": "list_files", "arguments": {"path": "."}}'
-                '</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.",
@@ -2068,18 +2327,6 @@ 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": (
@@ -2091,8 +2338,6 @@ async def debug_test_tool_parse(request: Request):
             "tool_calls_found": len(tool_calls),
             "tool_calls": tool_calls,
             "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}
@@ -2133,91 +2378,79 @@ async def debug_test_stream_buffer(request: Request):
 
 
 # =====================================================
-# نقطة تشخيص: اختبار حقن الهدف المستمر
+# نقطة تشخيص: اختبار PersistentContextStore
 # =====================================================
-@app.post("/debug/test-goal-injection")
-async def debug_test_goal_injection(request: Request):
+@app.post("/debug/test-context-store")
+async def debug_test_context_store(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)
+    test_session_id = f"test_{uuid.uuid4().hex[:8]}"
 
-    tools_list = [{"name": "write_file"}] if has_tools else []
-    history = []
+    # اختبار إنشاء جلسة
+    ctx = CONTEXT_STORE.get_or_create_session(test_session_id)
+    CONTEXT_STORE.update_session(
+        test_session_id,
+        original_task="Create a Python web scraper",
+        current_state="processing"
+    )
 
-    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."
-                )
-            }
-        ]
+    # اختبار إضافة خطوات
+    CONTEXT_STORE.add_completed_step(test_session_id, "Searched for Python scraping libraries")
+    CONTEXT_STORE.add_completed_step(test_session_id, "Found BeautifulSoup and requests")
 
-    # محاكاة ما سيحدث في ask()
-    has_tool_result_in_history = any(
-        "[SYSTEM]: Research results obtained" in str(item.get("content", ""))
-        for item in history
-        if isinstance(item, dict)
+    # اختبار إضافة نتائج أدوات
+    CONTEXT_STORE.add_tool_result(
+        test_session_id,
+        "web_search",
+        "toolu_test123",
+        "BeautifulSoup4, requests, scrapy are popular Python scraping libraries"
     )
 
-    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)"
+    # الحصول على ملخص السياق
+    summary = CONTEXT_STORE.get_context_summary(test_session_id)
+
+    # تنظيف الجلسة التجريبية
+    with CONTEXT_STORE._lock:
+        if test_session_id in CONTEXT_STORE._store:
+            del CONTEXT_STORE._store[test_session_id]
 
     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
+        "test_session_id": test_session_id,
+        "context_summary": summary,
+        "test_passed": len(summary) > 0,
+        "summary_length": len(summary)
     }
 
 
 @app.post("/chat")
 async def chat(request: Request, chat_req: ChatRequest):
     verify_api_key(request)
+    session_id = chat_req.session_id or f"chat_{uuid.uuid4().hex[:16]}"
     result = ""
     for chunk in ask(
-        chat_req.message, chat_req.history, chat_req.provider, chat_req.model
+        chat_req.message,
+        chat_req.history,
+        chat_req.provider,
+        chat_req.model,
+        session_id=session_id
     ):
         result += chunk
-    return JSONResponse({"response": result})
+    return JSONResponse({"response": result, "session_id": session_id})
 
 
 @app.post("/chat/stream")
 async def chat_stream(request: Request, chat_req: ChatRequest):
     verify_api_key(request)
+    session_id = chat_req.session_id or f"chat_{uuid.uuid4().hex[:16]}"
 
     async def generate():
         for chunk in ask(
-            chat_req.message, chat_req.history, chat_req.provider, chat_req.model
+            chat_req.message,
+            chat_req.history,
+            chat_req.provider,
+            chat_req.model,
+            session_id=session_id
         ):
             yield f"data: {json.dumps({'delta': chunk}, ensure_ascii=False)}\n\n"
         yield "data: [DONE]\n\n"
@@ -2312,18 +2545,40 @@ async def rate_limit_handler(request: Request, exc: HTTPException):
     )
 
 
+# =====================================================
+# مهمة تنظيف دورية للجلسات القديمة
+# =====================================================
+@app.on_event("startup")
+async def startup_event():
+    """تشغيل مهام عند بدء الخادم"""
+    logger.info("Starting G4F Smart Router v4.0 (Fixed Version)")
+    logger.info(f"Cookies: {COOKIE_STATUS}")
+    logger.info(f"Providers: {list(REAL_PROVIDERS.keys())}")
+    logger.info("Key Fixes:")
+    logger.info("  ✅ Removed STRICT MODE (was breaking model responses)")
+    logger.info("  ✅ Added PersistentContextStore (prevents forgetting)")
+    logger.info("  ✅ Added SmartHistoryManager (intelligent compression)")
+    logger.info("  ✅ Fixed Fallback order (uses requested provider first)")
+    logger.info("  ✅ Balanced tool instructions (clear, not aggressive)")
+    logger.info("  ✅ Added session tracking across model switches")
+
+    # بدء مهمة التنظيف الدورية
+    asyncio.create_task(periodic_cleanup())
+
+
+async def periodic_cleanup():
+    """تنظيف دوري للجلسات القديمة كل ساعة"""
+    while True:
+        await asyncio.sleep(3600)  # كل ساعة
+        CONTEXT_STORE.cleanup_old_sessions(max_age_hours=24)
+        logger.info("[Cleanup] Periodic cleanup completed")
+
+
 # =====================================================
 # التشغيل
 # =====================================================
 if __name__ == "__main__":
     import uvicorn
     port = int(os.getenv("PORT", 7860))
-    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 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()")
+    logger.info(f"Starting G4F Smart Router v4.0 on port {port}")
     uvicorn.run("app:app", host="0.0.0.0", port=port, reload=False)