Update app.py

app.py

@@ -1,19 +1,25 @@
 #!/usr/bin/env python3
 """
-gemini-web2api Enhanced — Agent Edition
-========================================
-النسخة المحسّنة مع دعم كامل لـ Agent Loop (ReAct) وTool Calling موثوق.
-
-التحسينات الجديدة:
-- ✅ إصلاح MODELS dict (خطأ syntax كان موجوداً)
+gemini-web2api + Zep Cloud Memory — Professional Agent Edition
+===============================================================
+نسخة احترافية كاملة مع:
+- ✅ Zep Cloud: ذاكرة دائمة عبر كل الجلسات (حقائق + ملخص + بحث دلالي)
 - ✅ Agent Loop حقيقي (ReAct: Reason → Act → Observe → Repeat)
-- ✅ System Prompt قوي ومُفصَّل للأدوات
-- ✅ JSON Tool Call parser محسّن مع fallback متعدد المستويات
-- ✅ Streaming مع Tool Calls (chunk-by-chunk)
-- ✅ حد أقصى للتكرار (max_iterations) لمنع الحلقات اللانهائية
-- ✅ Tool result injection صحيح في محادثات Gemini
-- ✅ Parallel tool calls دعم
-- ✅ تسجيل تفصيلي لكل خطوة Agent
+- ✅ Tool Calling موثوق مع JSON parser متعدد المستويات
+- ✅ Streaming حقيقي مع Tool Calls
+- ✅ SQLite Cache + Rate Limiting
+- ✅ Retry Logic + Fallback للنموذج الافتراضي
+- ✅ Gradio UI محسّن
+
+المتطلبات:
+    pip install fastapi uvicorn aiosqlite httpx gradio zep-cloud pydantic
+
+متغيرات البيئة:
+    ZEP_API_KEY     - مفتاح Zep Cloud (مطلوب للذاكرة الدائمة)
+    API_KEYS        - مفاتيح API مفصولة بفاصلة (افتراضي: sk-gemini)
+    GEMINI_COOKIE   - كوكي Gemini (اختياري، يُحسّن الجودة)
+    HTTPS_PROXY     - بروكسي (اختياري)
+    GEMINI_BL       - Gemini BL header (اختياري)
 """
 
 import asyncio
@@ -26,10 +32,9 @@ import ssl
 import sys
 import uuid
 import argparse
-import base64
 import urllib.parse
 import urllib.request
-from typing import Optional, List, Dict, Any, Tuple
+from typing import Optional, List, Dict, Any, Tuple, Callable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 
@@ -47,32 +52,58 @@ try:
 except ImportError:
     HAS_HTTPX = False
 
-__version__ = "2.1.0-agent"
+try:
+    from zep_cloud.client import AsyncZep
+    from zep_cloud.types import Message as ZepMessage
+    HAS_ZEP = True
+except ImportError:
+    HAS_ZEP = False
+
+__version__ = "3.0.0-zep"
 
+# ═══════════════════════════════════════════════════════════════════════════════
 # ─── Configuration ────────────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 def load_config() -> dict:
     defaults = {
+        # ─── Server
         "port": 7860,
         "host": "0.0.0.0",
-        "retry_attempts": 3,
-        "retry_delay_sec": 2,
-        "request_timeout_sec": 180,
+        "log_requests": True,
+
+        # ─── Gemini
         "gemini_bl": "boq_assistant-bard-web-server_20260525.09_p0",
         "default_model": "gemini-3.5-flash",
-        "log_requests": True,
         "cookie_file": None,
         "proxy": None,
+        "retry_attempts": 3,
+        "retry_delay_sec": 2,
+        "request_timeout_sec": 180,
+
+        # ─── API
         "api_keys": ["sk-gemini"],
         "rate_limit_per_minute": 20,
+
+        # ─── Cache
         "cache_ttl_seconds": 3600,
         "db_path": "cache.db",
         "cleanup_interval_seconds": 300,
-        # ✅ جديد: إعدادات Agent Loop
-        "agent_max_iterations": 8,        # حد أقصى لدورات الأداة
-        "agent_max_tokens_per_step": 4096, # حد التوكنز لكل خطوة
+
+        # ─── Agent Loop
+        "agent_max_iterations": 10,
+        "agent_max_tokens_per_step": 4096,
+
+        # ─── Zep Cloud Memory
+        "zep_api_key": os.environ.get("ZEP_API_KEY", ""),
+        "zep_memory_type": "perpetual",      # perpetual | summary_retriever
+        "zep_min_fact_rating": 0.3,          # حد أدنى لجودة الحقائق
+        "zep_recent_messages": 20,           # عدد الرسائل الأخيرة في السياق
+        "zep_search_limit": 5,               # نتائج البحث الدلالي
+        "zep_save_system_msgs": False,       # هل تحفظ رسائل النظام؟
     }
 
+    # تحميل ملف الإعدادات إذا وُجد
     for p in ["./config.json", os.path.expanduser("~/.config/gemini-web2api/config.json")]:
         if os.path.exists(p):
             try:
@@ -80,9 +111,10 @@ def load_config() -> dict:
                     defaults.update(json.load(f))
                 print(f"[Config] Loaded: {p}")
             except Exception as e:
-                print(f"[Config] Error loading {p}: {e}")
+                print(f"[Config] Error: {e}")
             break
 
+    # متغيرات البيئة تُلغي الإعدادات
     if os.environ.get("API_KEYS"):
         defaults["api_keys"] = [k.strip() for k in os.environ["API_KEYS"].split(",") if k.strip()]
     if os.environ.get("GEMINI_COOKIE"):
@@ -91,19 +123,22 @@ def load_config() -> dict:
         defaults["proxy"] = os.environ.get("HTTPS_PROXY") or os.environ.get("HTTP_PROXY")
     if os.environ.get("GEMINI_BL"):
         defaults["gemini_bl"] = os.environ["GEMINI_BL"]
+    if os.environ.get("ZEP_API_KEY"):
+        defaults["zep_api_key"] = os.environ["ZEP_API_KEY"]
 
     return defaults
 
 CONFIG = load_config()
 
-# ─── Models ──────────────────────────────────────────────────────────────────
-# ✅ إصلاح: كانت هناك أخطاء syntax (قوس مفقود + تكرار مفاتيح)
+# ═══════════════════════════════════════════════════════════════════════════════
+# ─── Models ───────────────────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 MODELS = {
     "gemini-3.7-flash": {
         "mode": 1, "think": 4,
         "desc": "Fast general-purpose model (~12k chars)",
-    },  # ← القوس كان مفقوداً في الكود الأصلي
+    },
     "gemini-3.6-flash": {
         "mode": 1, "think": 4,
         "desc": "All-around model (Gemini 3.6 Flash)",
@@ -114,11 +149,11 @@ MODELS = {
     },
     "gemini-3.5-flash-thinking": {
         "mode": 2, "think": 0,
-        "desc": "Deep thinking mode, longest output (~20k chars)",
+        "desc": "Deep thinking mode (~20k chars)",
     },
     "gemini-3.1-pro": {
         "mode": 3, "think": 4,
-        "desc": "Pro model (requires cookie for real routing)",
+        "desc": "Pro model",
     },
     "gemini-auto": {
         "mode": 4, "think": 4,
@@ -126,16 +161,17 @@ MODELS = {
     },
     "gemini-3.5-flash-thinking-lite": {
         "mode": 5, "think": 0,
-        "desc": "Dynamic thinking with adaptive depth (~15k chars)",
+        "desc": "Dynamic thinking (~15k chars)",
     },
-    # ✅ إصلاح: كان "claude-opus-4-6" مكرراً بخطأ، والصحيح هو نموذج Gemini خفيف
     "gemini-flash-lite": {
         "mode": 6, "think": 4,
         "desc": "Lightweight fast model (~10k chars)",
     },
 }
 
+# ═══════════════════════════════════════════════════════════════════════════════
 # ─── Pydantic Schemas ─────────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 class ChatMessage(BaseModel):
     role: str
@@ -154,7 +190,23 @@ class ChatCompletionRequest(BaseModel):
     tool_choice: Optional[Any] = "auto"
     user: Optional[str] = "default"
 
-# ─── Production Services ──────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
+# ─── Logging ──────────────────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def log(msg: str, level: str = "INFO"):
+    if CONFIG.get("log_requests"):
+        icons = {
+            "INFO": "ℹ️", "AGENT": "🤖", "TOOL": "🔧",
+            "ERROR": "❌", "WARN": "⚠️", "MEM": "🧠",
+        }
+        icon = icons.get(level, "•")
+        sys.stderr.write(f"[{time.strftime('%H:%M:%S')}] {icon} {msg}\n")
+        sys.stderr.flush()
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# ─── Services (Cache + Rate Limit) ────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 @dataclass
 class RateLimitEntry:
@@ -240,15 +292,347 @@ class Services:
 
 services = Services()
 
-# ─── Logging ──────────────────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
+# ─── Zep Cloud Memory Manager ─────────────────────────────────────════════════
+# ═══════════════════════════════════════════════════════════════════════════════
 
-def log(msg: str, level: str = "INFO"):
-    if CONFIG.get("log_requests"):
-        prefix = {"INFO": "ℹ️", "AGENT": "🤖", "TOOL": "🔧", "ERROR": "❌", "WARN": "⚠️"}.get(level, "•")
-        sys.stderr.write(f"[{time.strftime('%H:%M:%S')}] {prefix} {msg}\n")
-        sys.stderr.flush()
+class ZepMemoryManager:
+    """
+    مدير الذاكرة الدائمة عبر Zep Cloud.
+
+    الميزات:
+    ─────────
+    • كل user_id → جلسة (session) ثابتة لا تُمسح بين الدردشات
+    • يسترجع: الحقائق المستخرجة + ملخص المحادثة + آخر N رسالة
+    • يبحث دلالياً في كامل تاريخ المحادثة بناءً على السؤال الحالي
+    • يحفظ كل رسالة (user + assistant + tool) تلقائياً بعد كل رد
+    • يتعامل مع تغيير الموضوع: كل رسالة مرتبطة بـ timestamp وسياق
+    """
+
+    def __init__(self):
+        self.client: Optional[AsyncZep] = None
+        self._enabled = False
+        self._init_error: str = ""
+
+    async def init(self):
+        """تهيئة عميل Zep Cloud."""
+        if not HAS_ZEP:
+            self._init_error = "zep-cloud not installed. Run: pip install zep-cloud"
+            log(self._init_error, "WARN")
+            return
+
+        api_key = CONFIG.get("zep_api_key", "").strip()
+        if not api_key:
+            self._init_error = "ZEP_API_KEY not set — persistent memory disabled"
+            log(self._init_error, "WARN")
+            return
+
+        try:
+            self.client = AsyncZep(api_key=api_key)
+            # اختبار الاتصال
+            await self.client.user.list(page_number=1, page_size=1)
+            self._enabled = True
+            log("✅ Zep Cloud memory connected and ready", "MEM")
+        except Exception as e:
+            self._init_error = f"Zep Cloud connection failed: {e}"
+            log(self._init_error, "ERROR")
+
+    @property
+    def enabled(self) -> bool:
+        return self._enabled and self.client is not None
+
+    # ─── Session Management ────────────────────────────────────────────────────
+
+    def _session_id(self, user_id: str) -> str:
+        """
+        session_id ثابت ومبني على user_id.
+        لا يتغير بين الجلسات → هذا هو مفتاح الاستمرارية.
+        """
+        safe = re.sub(r'[^a-zA-Z0-9_-]', '_', user_id)
+        return f"agent_{safe}"
+
+    async def ensure_user_session(self, user_id: str) -> bool:
+        """
+        ينشئ المستخدم والجلسة في Zep إن لم تكونا موجودَين.
+        يعيد True عند النجاح.
+        """
+        if not self.enabled:
+            return False
+        try:
+            session_id = self._session_id(user_id)
+
+            # إنشاء المستخدم (يتجاهل الخطأ إذا كان موجوداً)
+            try:
+                await self.client.user.add(
+                    user_id=user_id,
+                    metadata={
+                        "source": "gemini-web2api",
+                        "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+                    }
+                )
+                log(f"Created Zep user: {user_id}", "MEM")
+            except Exception:
+                pass  # المستخدم موجود بالفعل
+
+            # إنشاء الجلسة (يتجاهل الخطأ إذا كانت موجودة)
+            try:
+                await self.client.memory.add_session(
+                    session_id=session_id,
+                    user_id=user_id,
+                    metadata={
+                        "agent_version": __version__,
+                        "model": CONFIG.get("default_model"),
+                    }
+                )
+                log(f"Created Zep session: {session_id}", "MEM")
+            except Exception:
+                pass  # الجلسة موجودة بالفعل
+
+            return True
+        except Exception as e:
+            log(f"ensure_user_session error: {e}", "WARN")
+            return False
+
+    # ─── Memory Retrieval ──────────────────────────────────────────────────────
+
+    async def get_full_context(self, user_id: str, current_query: str = "") -> str:
+        """
+        يسترجع السياق الكامل من Zep ويُعيده كنص منسَّق.
+
+        يشمل:
+        1. الحقائق المستخرجة تلقائياً (مثل: اسم المستخدم، تفضيلاته، مهامه)
+        2. ملخص تلقائي لكل المحادثات السابقة
+        3. آخر N رسالة للسياق الفوري
+        4. نتائج بحث دلالي إذا كان هناك استعلام
+
+        هذا يضمن:
+        - تذكر تغييرات الموضوع (كل شيء مُدوَّن)
+        - الحفاظ على السياق في المحادثات الطويلة جداً
+        - استرجاع المعلومات ذات الصلة حتى من محادثات قديمة
+        """
+        if not self.enabled:
+            return ""
+
+        session_id = self._session_id(user_id)
+        parts = []
+
+        try:
+            # ─── 1. الذاكرة الأساسية (حقائق + ملخص + رسائل أخيرة)
+            memory = await self.client.memory.get(
+                session_id=session_id,
+                min_rating=CONFIG.get("zep_min_fact_rating", 0.3),
+            )
+
+            # الحقائق المستخرجة تلقائياً من كل المحادثات
+            if hasattr(memory, 'facts') and memory.facts:
+                facts_lines = []
+                for f in memory.facts:
+                    fact_text = f if isinstance(f, str) else getattr(f, 'fact', str(f))
+                    if fact_text:
+                        facts_lines.append(f"  • {fact_text}")
+                if facts_lines:
+                    parts.append(
+                        "### KNOWN FACTS (extracted automatically from all past conversations)\n"
+                        + "\n".join(facts_lines)
+                    )
+
+            # الملخص التلقائي للمحادثات السابقة
+            if hasattr(memory, 'summary') and memory.summary:
+                summary_text = (
+                    memory.summary if isinstance(memory.summary, str)
+                    else getattr(memory.summary, 'content', '')
+                )
+                if summary_text and summary_text.strip():
+                    parts.append(
+                        "### CONVERSATION HISTORY SUMMARY\n"
+                        + summary_text.strip()
+                    )
+
+            # آخر الرسائل للسياق الفوري
+            if hasattr(memory, 'messages') and memory.messages:
+                n = CONFIG.get("zep_recent_messages", 20)
+                recent = memory.messages[-n:] if len(memory.messages) > n else memory.messages
+                if recent:
+                    lines = []
+                    for m in recent:
+                        role = getattr(m, 'role_type', getattr(m, 'role', 'user'))
+                        content = getattr(m, 'content', '') or ''
+                        if content.strip():
+                            lines.append(f"  [{role.upper()}]: {content.strip()}")
+                    if lines:
+                        parts.append(
+                            f"### RECENT MESSAGES (last {len(recent)})\n"
+                            + "\n".join(lines)
+                        )
+
+        except Exception as e:
+            log(f"get_memory error: {e}", "WARN")
+
+        # ─── 2. البحث الدلالي بناءً على الاستعلام الحالي
+        if current_query and current_query.strip():
+            try:
+                search_results = await self.client.memory.search_sessions(
+                    text=current_query,
+                    user_id=user_id,
+                    limit=CONFIG.get("zep_search_limit", 5),
+                )
+                if search_results and hasattr(search_results, 'results') and search_results.results:
+                    relevant_lines = []
+                    for r in search_results.results:
+                        msg = getattr(r, 'message', None)
+                        if msg:
+                            content = getattr(msg, 'content', '') or ''
+                            role = getattr(msg, 'role_type', 'unknown')
+                            score = getattr(r, 'score', 0)
+                            if content.strip() and score > 0.5:
+                                relevant_lines.append(
+                                    f"  [{role.upper()}] (relevance: {score:.2f}): {content.strip()}"
+                                )
+                    if relevant_lines:
+                        parts.append(
+                            "### SEMANTICALLY RELEVANT PAST CONTEXT (for current query)\n"
+                            + "\n".join(relevant_lines)
+                        )
+            except Exception as e:
+                log(f"semantic search error: {e}", "WARN")
+
+        if not parts:
+            return ""
+
+        # ─── بناء السياق النهائي
+        context = (
+            "╔══════════════════════════════════════════════════════════╗\n"
+            "║  PERSISTENT MEMORY — CROSS-SESSION CONTEXT              ║\n"
+            "║  Use this to maintain full continuity across all chats  ║\n"
+            "╚══════════════════════════════════════════════════════════╝\n\n"
+            + "\n\n".join(parts)
+            + "\n\n[END OF PERSISTENT MEMORY]"
+        )
+        log(f"Retrieved memory context ({len(context)} chars) for user={user_id}", "MEM")
+        return context
+
+    # ─── Memory Saving ─────────────────────────────────────────────────────────
+
+    async def save_turn(self, user_id: str, messages: List[dict], assistant_reply: str = ""):
+        """
+        يحفظ دوران المحادثة (رسائل المستخدم + رد المساعد) في Zep.
+
+        يُستدعى بعد كل رد ناجح.
+        Zep يستخرج الحقائق ويُحدّث الملخص تلقائياً في الخلفية.
+        """
+        if not self.enabled:
+            return
+
+        session_id = self._session_id(user_id)
+        zep_msgs = []
+
+        try:
+            for msg in messages:
+                role = msg.get("role", "user")
+                content = msg.get("content") or ""
+
+                # تجاهل رسائل النظام إذا كانت الإعدادات تمنعها
+                if role == "system" and not CONFIG.get("zep_save_system_msgs"):
+                    continue
+
+                # تحويل content القائمة إلى نص
+                if isinstance(content, list):
+                    content = " ".join(
+                        c.get("text", "") for c in content
+                        if isinstance(c, dict) and c.get("type") in ("text", "input_text")
+                    )
+
+                content = (content or "").strip()
+                if not content:
+                    continue
+
+                # تحويل tool calls إلى نص قابل للقراءة
+                tool_calls_data = msg.get("tool_calls")
+                if tool_calls_data and role == "assistant":
+                    tc_summary = json.dumps(
+                        [{"tool": tc["function"]["name"], "args": tc["function"].get("arguments", "{}")}
+                         for tc in tool_calls_data],
+                        ensure_ascii=False
+                    )
+                    content = f"{content}\n[Tool calls: {tc_summary}]" if content else f"[Tool calls: {tc_summary}]"
+
+                role_map = {
+                    "user": "user",
+                    "assistant": "assistant",
+                    "tool": "tool",
+                    "system": "system",
+                }
+                zep_role = role_map.get(role, "user")
+
+                zep_msgs.append(
+                    ZepMessage(
+                        role_type=zep_role,
+                        role=role,
+                        content=content,
+                    )
+                )
+
+            # إضافة رد المساعد إذا لم يكن في القائمة
+            if assistant_reply and assistant_reply.strip():
+                already_saved = any(
+                    m.get("role") == "assistant" and (m.get("content") or "") == assistant_reply
+                    for m in messages
+                )
+                if not already_saved:
+                    zep_msgs.append(
+                        ZepMessage(
+                            role_type="assistant",
+                            role="assistant",
+                            content=assistant_reply.strip(),
+                        )
+                    )
+
+            if zep_msgs:
+                await self.client.memory.add(
+                    session_id=session_id,
+                    messages=zep_msgs,
+                )
+                log(f"💾 Saved {len(zep_msgs)} messages to Zep (user={user_id})", "MEM")
+
+        except Exception as e:
+            log(f"save_turn error: {e}", "WARN")
+
+    async def add_fact(self, user_id: str, fact: str):
+        """
+        إضافة حقيقة صريحة يذكرها المستخدم (للأشياء المهمة جداً).
+        Zep يستخرج الحقائق تلقائياً أيضاً، لكن هذا للتأكيد.
+        """
+        if not self.enabled:
+            return
+        try:
+            session_id = self._session_id(user_id)
+            await self.client.memory.add(
+                session_id=session_id,
+                messages=[
+                    ZepMessage(
+                        role_type="system",
+                        role="system",
+                        content=f"[IMPORTANT FACT]: {fact}",
+                    )
+                ]
+            )
+            log(f"Added explicit fact for user={user_id}: {fact[:50]}...", "MEM")
+        except Exception as e:
+            log(f"add_fact error: {e}", "WARN")
 
+    def status(self) -> dict:
+        return {
+            "enabled": self.enabled,
+            "provider": "Zep Cloud",
+            "error": self._init_error if not self.enabled else None,
+        }
+
+# المثيل العام
+zep_memory = ZepMemoryManager()
+
+# ═══════════════════════════════════════════════════════════════════════════════
 # ─── Cookie & Headers ─────────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 def load_cookie() -> Tuple[str, Optional[str]]:
     inline = CONFIG.get("_cookie_inline", "")
@@ -301,7 +685,9 @@ def _build_headers() -> dict:
         headers["Authorization"] = make_sapisidhash(sapisid)
     return headers
 
+# ═══════════════════════════════════════════════════════════════════════════════
 # ─── Gemini Protocol ──────────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 def _build_gemini_payload(prompt: str, model_id: int, think_mode: int) -> Tuple[bytes, str]:
     inner = [None] * 80
@@ -429,7 +815,8 @@ def gemini_stream_iter(prompt: str, model_id: int, think_mode: int):
                         inner2 = json.loads(inner_str)
                         if isinstance(inner2, list) and len(inner2) > 4 and inner2[4]:
                             for part in inner2[4]:
-                                if isinstance(part, list) and len(part) > 1 and part[1] and isinstance(part[1], list):
+                                if (isinstance(part, list) and len(part) > 1
+                                        and part[1] and isinstance(part[1], list)):
                                     for t in part[1]:
                                         if isinstance(t, str) and len(t) > len(prev_text):
                                             delta = t[len(prev_text):]
@@ -440,79 +827,64 @@ def gemini_stream_iter(prompt: str, model_id: int, think_mode: int):
                     except (json.JSONDecodeError, IndexError, TypeError):
                         pass
 
-# ─── ✅ Tool Call Parser المحسّن ──────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
+# ─── Tool Call Parser ───────────────────────────────────��─────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 def parse_tool_calls(text: str) -> Tuple[str, Optional[List[dict]]]:
     """
-    محلّل Tool Calls متعدد المستويات:
-    1. ```tool_call {...}```
-    2. ```json {"name": ..., "arguments": ...}```
-    3. <tool_call>...</tool_call>
-    4. JSON مباشر في النص
+    محلّل Tool Calls متعدد المستويات (4 أنماط).
     """
     tool_calls = []
 
-    # ─── مستوى 1: ```tool_call``` blocks
-    pattern1 = r'```tool_call\s*\n(.*?)\n?```'
-    for match in re.finditer(pattern1, text, re.DOTALL):
-        raw = match.group(1).strip()
-        tc = _try_parse_single_tool_call(raw)
+    # النمط 1: ```tool_call {...}```
+    p1 = r'```tool_call\s*\n(.*?)\n?```'
+    for m in re.finditer(p1, text, re.DOTALL):
+        tc = _try_parse_tc(m.group(1).strip())
         if tc:
             tool_calls.append(tc)
 
-    # ─── مستوى 2: ```json``` blocks التي تحتوي على tool call
+    # النمط 2: ```json {...}``` (يحتوي على name + arguments)
     if not tool_calls:
-        pattern2 = r'```json\s*\n(.*?)\n?```'
-        for match in re.finditer(pattern2, text, re.DOTALL):
-            raw = match.group(1).strip()
-            tc = _try_parse_single_tool_call(raw)
+        p2 = r'```json\s*\n(.*?)\n?```'
+        for m in re.finditer(p2, text, re.DOTALL):
+            tc = _try_parse_tc(m.group(1).strip())
             if tc:
                 tool_calls.append(tc)
 
-    # ─── مستوى 3: XML-style <tool_call>
+    # النمط 3: <tool_call>...</tool_call>
     if not tool_calls:
-        pattern3 = r'<tool_call>(.*?)</tool_call>'
-        for match in re.finditer(pattern3, text, re.DOTALL):
-            raw = match.group(1).strip()
-            tc = _try_parse_single_tool_call(raw)
+        p3 = r'<tool_call>(.*?)</tool_call>'
+        for m in re.finditer(p3, text, re.DOTALL):
+            tc = _try_parse_tc(m.group(1).strip())
             if tc:
                 tool_calls.append(tc)
 
-    # ─── مستوى 4: JSON مباشر (للنماذج التي تُخرج JSON مباشرة)
+    # النمط 4: JSON مباشر
     if not tool_calls:
-        # ابحث عن JSON objects تحتوي على "name" و "arguments"
-        json_pattern = r'\{[^{}]*"name"\s*:\s*"[^"]+[^{}]*"arguments"\s*:[^{}]*\}'
-        for match in re.finditer(json_pattern, text, re.DOTALL):
-            tc = _try_parse_single_tool_call(match.group(0))
+        jp = r'\{[^{}]*"name"\s*:\s*"[^"]+[^{}]*"arguments"\s*:[^{}]*\}'
+        for m in re.finditer(jp, text, re.DOTALL):
+            tc = _try_parse_tc(m.group(0))
             if tc:
                 tool_calls.append(tc)
 
     if not tool_calls:
         return text, None
 
-    # تنظيف النص من أجزاء tool calls
-    clean = re.sub(pattern1, '', text, flags=re.DOTALL)
+    # تنظيف النص
+    clean = re.sub(p1, '', text, flags=re.DOTALL)
     clean = re.sub(r'```json\s*\n.*?\n?```', '', clean, flags=re.DOTALL)
     clean = re.sub(r'<tool_call>.*?</tool_call>', '', clean, flags=re.DOTALL)
-    # إزالة أي JSON مباشر كان tool call
-    for tc_obj in tool_calls:
-        fn_name = tc_obj["function"]["name"]
-        clean = re.sub(
-            r'\{[^{}]*"name"\s*:\s*"' + re.escape(fn_name) + r'"[^{}]*\}',
-            '', clean
-        )
 
     return clean.strip(), tool_calls
 
-def _try_parse_single_tool_call(raw: str) -> Optional[dict]:
-    """محاولة تحليل tool call واحد من نص."""
+
+def _try_parse_tc(raw: str) -> Optional[dict]:
     try:
         data = json.loads(raw)
     except json.JSONDecodeError:
-        # محاولة إصلاح JSON المكسور
-        raw_fixed = _fix_json(raw)
         try:
-            data = json.loads(raw_fixed)
+            data = json.loads(_fix_json(raw))
         except json.JSONDecodeError:
             return None
 
@@ -539,107 +911,108 @@ def _try_parse_single_tool_call(raw: str) -> Optional[dict]:
         },
     }
 
+
 def _fix_json(s: str) -> str:
-    """إصلاح JSON المكسور جزئياً."""
-    # إزالة trailing commas
     s = re.sub(r',\s*([}\]])', r'\1', s)
-    # إضافة quotes للمفاتيح غير المُقتبَسة
     s = re.sub(r'(\w+)\s*:', r'"\1":', s)
-    # إزالة double quotes
     s = re.sub(r'""(\w+)""', r'"\1"', s)
     return s
 
-# ─── ✅ Tool/Agent System Prompt المحسّن ──────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
+# ─── Agent System Prompt ──────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
-AGENT_SYSTEM_PROMPT = """You are a helpful AI assistant with access to tools. You MUST use tools when they are needed to answer the user's request accurately.
+AGENT_SYSTEM_PROMPT = """You are a professional AI assistant with persistent memory and access to tools.
 
-## HOW TO USE TOOLS
+## MEMORY INSTRUCTIONS
+- The [PERSISTENT MEMORY] block above contains everything you remember about this user from ALL previous conversations.
+- Use this memory to maintain full continuity even when topics change suddenly.
+- If the user references something from a past conversation, look it up in the memory block first.
+- Facts, preferences, tasks, and details from previous chats are all available to you.
 
-When you need to call a tool, you MUST respond with a tool_call block in this EXACT format:
+## TOOL USAGE
+When you need to call a tool, use this EXACT format:
 
 ```tool_call
 {"name": "tool_name_here", "arguments": {"param1": "value1", "param2": "value2"}}
 ```
 
-## IMPORTANT RULES
-
-1. **Always use tools when available** - Do not guess or make up information that a tool can provide.
-2. **One tool at a time** - Call tools one by one unless you need multiple simultaneously.
-3. **Wait for results** - After calling a tool, wait for the tool result before continuing.
-4. **Use results** - Incorporate tool results into your final answer.
-5. **Be explicit** - Always explain what tool you're calling and why.
+### Rules:
+1. Always use tools when they are needed — do not guess information a tool can provide.
+2. Call tools one at a time and wait for the result before calling the next.
+3. Incorporate tool results into your final answer.
+4. Never fabricate tool results.
+5. If a tool fails, explain what happened and try an alternative approach.
 
 ## AVAILABLE TOOLS
 
 {tool_definitions}
 
-## RESPONSE FORMAT
-
-- If you need a tool: respond with ONLY the tool_call block (no extra text before it).
-- If you have all information needed: provide your final answer directly.
-- Never call a tool you don't have access to.
-- Never fabricate tool results.
-
-## EXAMPLE
-
-User: What's the weather in Paris?
-Assistant:
-```tool_call
-{"name": "get_weather", "arguments": {"location": "Paris", "unit": "celsius"}}
-```
-
-[After receiving tool result]
-Assistant: Based on the weather data, Paris currently has...
+## RESPONSE STYLE
+- Be thorough and professional in task execution.
+- Acknowledge when you remember something from a previous conversation.
+- If topics change mid-conversation, handle the new topic fully while retaining all past context.
+- Respond in the same language the user uses.
 """
 
 def build_tool_definitions_text(tools: List[dict]) -> str:
-    """بناء وصف نصي للأدوات المتاحة."""
     if not tools:
-        return "No tools available."
+        return "No tools currently available."
     lines = []
     for i, tool in enumerate(tools, 1):
-        if tool.get("type") == "function":
-            fn = tool.get("function", tool)
-        else:
-            fn = tool
+        fn = tool.get("function", tool) if tool.get("type") == "function" else tool
         name = fn.get("name", f"tool_{i}")
         desc = fn.get("description", "No description")
         params = fn.get("parameters", {})
-
         lines.append(f"### {i}. `{name}`")
         lines.append(f"**Description:** {desc}")
-
         if params and params.get("properties"):
             lines.append("**Parameters:**")
-            for pname, pinfo in params.get("properties", {}).items():
-                required = pname in params.get("required", [])
+            for pname, pinfo in params["properties"].items():
+                req = pname in params.get("required", [])
                 ptype = pinfo.get("type", "any")
                 pdesc = pinfo.get("description", "")
-                req_str = " *(required)*" if required else " *(optional)*"
-                lines.append(f"  - `{pname}` ({ptype}){req_str}: {pdesc}")
+                lines.append(f"  - `{pname}` ({ptype}){'*' if req else ''}: {pdesc}")
         lines.append("")
     return "\n".join(lines)
 
+# ═══════════════════════════════════════════════════════════════════════════════
 # ─── Prompt Builder ───────────────────────────────────────────────────────────
+# ═══════════════════════════════════════��═══════════════════════════════════════
 
-def messages_to_prompt(messages: list, tools: list = None) -> str:
+def messages_to_prompt(
+    messages: list,
+    tools: list = None,
+    memory_context: str = "",
+) -> str:
     """
-    ✅ محسّن: يبني prompt واضحاً مع system prompt قوي للأدوات.
+    يبني prompt كامل بالترتيب:
+    1. ذاكرة Zep (السياق الدائم عبر الجلسات)
+    2. System prompt الأدوات (إذا كانت هناك أدوات)
+    3. رسائل المحادثة الحالية
     """
     parts = []
 
-    # ─── System prompt للأدوات
+    # ─── 1. الذاكرة الدائمة أولاً (الأعلى أولوية)
+    if memory_context and memory_context.strip():
+        parts.append(memory_context)
+
+    # ─── 2. System prompt للأدوات
     if tools:
-        tool_defs_text = build_tool_definitions_text(tools)
-        system_tool_prompt = AGENT_SYSTEM_PROMPT.replace("{tool_definitions}", tool_defs_text)
-        parts.append(f"[SYSTEM]\n{system_tool_prompt}")
+        tool_defs = build_tool_definitions_text(tools)
+        sys_prompt = AGENT_SYSTEM_PROMPT.replace("{tool_definitions}", tool_defs)
+        parts.append(f"[SYSTEM — AGENT INSTRUCTIONS]\n{sys_prompt}")
+    else:
+        parts.append(
+            "[SYSTEM]\nYou are a professional AI assistant with persistent memory. "
+            "Use the memory context above to maintain continuity across all conversations."
+        )
 
-    # ─── معالجة الرسائل
+    # ─── 3. معالجة رسائل المحادثة
     for msg in messages:
         role = msg.get("role", "user") if isinstance(msg, dict) else msg.role
         content = msg.get("content", "") if isinstance(msg, dict) else (msg.content or "")
-        tool_calls_data = (msg.get("tool_calls") if isinstance(msg, dict)
-                          else getattr(msg, "tool_calls", None))
+        tc_data = msg.get("tool_calls") if isinstance(msg, dict) else getattr(msg, "tool_calls", None)
 
         # تحويل content متعدد الأجزاء
         if isinstance(content, list):
@@ -647,125 +1020,127 @@ def messages_to_prompt(messages: list, tools: list = None) -> str:
                 c.get("text", "") for c in content
                 if isinstance(c, dict) and c.get("type") in ("text", "input_text")
             )
+        content = (content or "").strip()
 
         if role == "system":
-            if not tools:  # إذا كان هناك أدوات، system prompt الأدوات يأتي أولاً
-                parts.append(f"[SYSTEM]\n{content}")
-            else:
-                # دمج system prompt المستخدم مع system prompt الأدوات
-                parts[0] = parts[0] + f"\n\n## ADDITIONAL INSTRUCTIONS\n{content}"
+            # دمج system prompt المستخدم مع ما سبق
+            if content:
+                parts.append(f"[ADDITIONAL SYSTEM INSTRUCTIONS]\n{content}")
+
+        elif role == "user":
+            if content:
+                parts.append(f"[USER]: {content}")
 
         elif role == "assistant":
-            if tool_calls_data:
-                # تضمين tool calls السابقة في السياق
-                tc_parts = [f"[ASSISTANT called tool(s)]:"]
-                for tc in tool_calls_data:
-                    fn = tc.get("function", {})
-                    tc_parts.append(
-                        f"```tool_call\n"
-                        f"{json.dumps({'name': fn.get('name'), 'arguments': json.loads(fn.get('arguments', '{}'))}, ensure_ascii=False)}\n"
-                        f"```"
-                    )
+            if tc_data:
+                tc_str = "\n".join(
+                    f"```tool_call\n{json.dumps({'name': tc['function']['name'], 'arguments': json.loads(tc['function'].get('arguments', '{}'))}, ensure_ascii=False)}\n```"
+                    for tc in tc_data
+                )
+                assistant_part = ""
                 if content:
-                    tc_parts.insert(1, f"[ASSISTANT]: {content}")
-                parts.append("\n".join(tc_parts))
-            else:
+                    assistant_part = f"[ASSISTANT]: {content}\n"
+                assistant_part += f"[ASSISTANT called tools]:\n{tc_str}"
+                parts.append(assistant_part)
+            elif content:
                 parts.append(f"[ASSISTANT]: {content}")
 
         elif role == "tool":
-            # ✅ نتائج الأدوات بشكل واضح
-            tool_name = (msg.get("name", "") if isinstance(msg, dict)
-                        else getattr(msg, "name", ""))
-            tool_call_id = (msg.get("tool_call_id", "") if isinstance(msg, dict)
-                           else getattr(msg, "tool_call_id", ""))
-            parts.append(
-                f"[TOOL RESULT - {tool_name or tool_call_id}]:\n```json\n{content}\n```\n"
-                f"Now use this result to continue."
-            )
-
-        else:  # user
+            tool_name = msg.get("name", "") if isinstance(msg, dict) else getattr(msg, "name", "")
+            tool_id = msg.get("tool_call_id", "") if isinstance(msg, dict) else getattr(msg, "tool_call_id", "")
+            label = tool_name or tool_id or "unknown_tool"
             if content:
-                parts.append(f"[USER]: {content}")
+                parts.append(
+                    f"[TOOL RESULT — {label}]:\n```json\n{content}\n```\n"
+                    f"→ Continue based on this result."
+                )
 
-    return "\n\n".join(p for p in parts if p)
+    return "\n\n".join(p for p in parts if p and p.strip())
 
-# ─── ✅ Agent Loop الرئيسي ────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
+# ─── Agent Loop ───────────────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 def run_agent_sync(
     messages: List[dict],
     model_id: int,
     think_mode: int,
     tools: Optional[List[dict]],
+    memory_context: str = "",
     max_iterations: int = None,
 ) -> Tuple[str, Optional[List[dict]], List[dict]]:
     """
-    Agent Loop حقيقي (ReAct pattern):
-    1. ابنِ prompt من السياق الكامل
-    2. اسأل Gemini
-    3. إذا أعاد tool call → أضف إلى السياق واعد
-    4. إذا لم يُعد tool call → أعد الرد النهائي
+    Agent Loop (ReAct):
+    Reason → Act (tool call) → Observe (result) → Reason → ...
+
+    يعيد (final_text, tool_calls_if_any, updated_messages)
 
-    يعيد: (final_text, final_tool_calls, updated_messages)
+    ملاحظة: في وضع non-executor (الافتراضي)، يُعيد tool calls للـ client
+    ليُنفّذها ويُرسل النتائج في الطلب التالي. هذا هو السلوك الصحيح
+    لبروتوكول OpenAI Tool Calling.
     """
     if max_iterations is None:
         max_iterations = CONFIG["agent_max_iterations"]
 
     current_messages = list(messages)
-    iteration = 0
-    last_tool_calls = None
 
-    while iteration < max_iterations:
-        iteration += 1
+    for iteration in range(1, max_iterations + 1):
         log(f"Agent iteration {iteration}/{max_iterations}", "AGENT")
 
-        prompt = messages_to_prompt(current_messages, tools if iteration == 1 else tools)
-        raw = gemini_stream_generate(prompt, model_id, think_mode)
-        text = extract_response_text(raw)
+        # بناء الـ prompt مع الذاكرة
+        prompt = messages_to_prompt(current_messages, tools, memory_context)
+
+        try:
+            raw = gemini_stream_generate(prompt, model_id, think_mode)
+            text = extract_response_text(raw)
+        except Exception as e:
+            log(f"Gemini call error (iter {iteration}): {e}", "ERROR")
+            return f"[Error communicating with model: {e}]", None, current_messages
 
         if not text:
             log("Empty response from Gemini", "WARN")
+            if iteration == 1:
+                return "[No response from model]", None, current_messages
             break
 
-        # ─── محاولة تحليل tool calls
+        # تحليل tool calls
         clean_text, tool_calls = parse_tool_calls(text)
 
         if tool_calls and tools:
-            log(f"Tool calls detected: {[tc['function']['name'] for tc in tool_calls]}", "TOOL")
+            names = [tc["function"]["name"] for tc in tool_calls]
+            log(f"Tool calls detected: {names}", "TOOL")
 
-            # أضف رد المساعد مع tool calls إلى السياق
+            # أضف رد المساعد للسياق
             current_messages.append({
                 "role": "assistant",
                 "content": clean_text or None,
                 "tool_calls": tool_calls,
             })
-            last_tool_calls = tool_calls
 
-            # ✅ هنا يجب على المستدعي تنفيذ الأدوات وإضافة النتائج
-            # في وضع non-streaming، نُعيد tool calls للمستدعي
-            # في وضع agent داخلي، نضيف placeholder
-            return clean_text, tool_calls, current_messages
+            # أعد tool calls للـ client (OpenAI protocol)
+            return clean_text or "", tool_calls, current_messages
 
         else:
-            # ─── رد نهائي بدون tool calls
-            log(f"Final response after {iteration} iterations", "AGENT")
+            # رد نهائي
+            log(f"✅ Final answer at iteration {iteration}", "AGENT")
             return clean_text or text, None, current_messages
 
     log(f"Max iterations ({max_iterations}) reached", "WARN")
-    return text or "", None, current_messages
+    return text or "[Max iterations reached]", None, current_messages
 
 
-def run_agent_with_tool_execution_sync(
+def run_agent_with_executor_sync(
     messages: List[dict],
     model_id: int,
     think_mode: int,
     tools: Optional[List[dict]],
-    tool_executor=None,  # دالة لتنفيذ الأدوات (اختيارية)
+    tool_executor: Optional[Callable[[str, dict], str]],
+    memory_context: str = "",
     max_iterations: int = None,
 ) -> Tuple[str, Optional[List[dict]], List[dict]]:
     """
-    ✅ Agent Loop الكامل مع تنفيذ الأدوات تلقائياً (إذا توفّر executor).
-    
-    tool_executor: Callable[[str, dict], str] - يأخذ (tool_name, args) ويُعيد نتيجة نصية
+    Agent Loop الكامل مع تنفيذ الأدوات داخلياً.
+    يستخدم عندما يكون tool_executor متاحاً (نادر في هذا السيناريو).
     """
     if max_iterations is None:
         max_iterations = CONFIG["agent_max_iterations"]
@@ -773,35 +1148,31 @@ def run_agent_with_tool_execution_sync(
     current_messages = list(messages)
 
     for iteration in range(1, max_iterations + 1):
-        log(f"Agent loop iteration {iteration}/{max_iterations}", "AGENT")
+        log(f"[Full Agent] Iteration {iteration}/{max_iterations}", "AGENT")
 
-        prompt = messages_to_prompt(current_messages, tools)
+        prompt = messages_to_prompt(current_messages, tools, memory_context)
         try:
             raw = gemini_stream_generate(prompt, model_id, think_mode)
             text = extract_response_text(raw)
         except Exception as e:
-            log(f"Gemini call failed: {e}", "ERROR")
+            log(f"Gemini error: {e}", "ERROR")
             return f"Error: {e}", None, current_messages
 
         if not text:
-            log("Empty response", "WARN")
             break
 
         clean_text, tool_calls = parse_tool_calls(text)
 
         if not tool_calls or not tools:
-            # رد نهائي
-            log(f"✅ Final answer after {iteration} iterations", "AGENT")
+            log(f"✅ Final answer at iteration {iteration}", "AGENT")
             return clean_text or text, None, current_messages
 
-        # ─── أضف رد المساعد
         current_messages.append({
             "role": "assistant",
             "content": clean_text or None,
             "tool_calls": tool_calls,
         })
 
-        # ─── تنفيذ كل tool call
         for tc in tool_calls:
             fn_name = tc["function"]["name"]
             try:
@@ -809,7 +1180,7 @@ def run_agent_with_tool_execution_sync(
             except Exception:
                 fn_args = {}
 
-            log(f"Executing tool: {fn_name}({fn_args})", "TOOL")
+            log(f"Executing: {fn_name}({fn_args})", "TOOL")
 
             if tool_executor:
                 try:
@@ -817,10 +1188,9 @@ def run_agent_with_tool_execution_sync(
                     result_str = result if isinstance(result, str) else json.dumps(result, ensure_ascii=False)
                 except Exception as e:
                     result_str = json.dumps({"error": str(e)})
-                    log(f"Tool execution error: {e}", "ERROR")
+                    log(f"Tool error: {e}", "ERROR")
             else:
-                # لا يوجد executor، أضف placeholder
-                result_str = json.dumps({"status": "tool_executed", "note": "No executor provided"})
+                result_str = json.dumps({"status": "no_executor", "tool": fn_name})
 
             current_messages.append({
                 "role": "tool",
@@ -829,18 +1199,16 @@ def run_agent_with_tool_execution_sync(
                 "content": result_str,
             })
 
-        log(f"Tools executed, continuing loop...", "AGENT")
-
-    log(f"Max iterations reached", "WARN")
     return text or "", None, current_messages
 
 
-# ─── Sync wrapper ─────────────────────────────────────────────────────────────
-
 def call_gemini_sync(
-    prompt: str, model_id: int, think_mode: int, tools: list = None
+    prompt: str,
+    model_id: int,
+    think_mode: int,
+    tools: list = None,
 ) -> Tuple[str, Optional[list]]:
-    """استدعاء مزامن بسيط (بدون agent loop)."""
+    """استدعاء بسيط بدون agent loop."""
     raw = gemini_stream_generate(prompt, model_id, think_mode)
     text = extract_response_text(raw)
     tool_calls = None
@@ -848,7 +1216,9 @@ def call_gemini_sync(
         text, tool_calls = parse_tool_calls(text)
     return text or "", tool_calls
 
+# ════════��══════════════════════════════════════════════════════════════════════
 # ─── Model Resolution ─────────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 def resolve_model(model_name: str) -> Tuple[Optional[str], Optional[int], Optional[int], Optional[str]]:
     think_override = None
@@ -858,9 +1228,9 @@ def resolve_model(model_name: str) -> Tuple[Optional[str], Optional[int], Option
             think_override = int(think_str)
         except ValueError:
             pass
+
     cfg = MODELS.get(model_name)
     if not cfg:
-        # fallback للنموذج الافتراضي بدلاً من الخطأ المباشر
         default = CONFIG.get("default_model", "gemini-3.5-flash")
         cfg = MODELS.get(default)
         if cfg:
@@ -868,14 +1238,56 @@ def resolve_model(model_name: str) -> Tuple[Optional[str], Optional[int], Option
             model_name = default
         else:
             return None, None, None, f"Unknown model: {model_name}. Available: {list(MODELS.keys())}"
+
     return model_name, cfg["mode"], (think_override if think_override is not None else cfg["think"]), None
 
+# ═══════════════════════════════════════════════════════════════════════════════
+# ─── Helpers ──────────────────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def extract_last_user_query(messages: List[dict]) -> str:
+    """يستخرج آخر رسالة للمستخدم كنص للبحث الدلالي."""
+    for msg in reversed(messages):
+        if msg.get("role") == "user":
+            content = msg.get("content", "")
+            if isinstance(content, list):
+                content = " ".join(
+                    c.get("text", "") for c in content
+                    if isinstance(c, dict) and c.get("type") in ("text", "input_text")
+                )
+            return (content or "").strip()
+    return ""
+
+
+def _build_completion_response(
+    cid: str, created: int, model: str, text: str,
+    tool_calls: Optional[list], prompt: str = ""
+) -> dict:
+    msg: dict = {"role": "assistant", "content": text or None}
+    if tool_calls:
+        msg["tool_calls"] = tool_calls
+    finish = "tool_calls" if tool_calls else "stop"
+    return {
+        "id": cid,
+        "object": "chat.completion",
+        "created": created,
+        "model": model,
+        "choices": [{"index": 0, "message": msg, "finish_reason": finish}],
+        "usage": {
+            "prompt_tokens": len(prompt) // 4,
+            "completion_tokens": len(text) // 4 if text else 0,
+            "total_tokens": (len(prompt) + len(text)) // 4 if text else len(prompt) // 4,
+        },
+    }
+
+# ═══════════════════════════════════════════════════════════════════════════════
 # ─── Authentication ───────────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 security = HTTPBearer(auto_error=False)
 
 async def verify_api_key(
-    credentials: Optional[HTTPAuthorizationCredentials] = Depends(security)
+    credentials: Optional[HTTPAuthorizationCredentials] = Depends(security),
 ) -> str:
     api_keys = CONFIG.get("api_keys", [])
     if not api_keys:
@@ -887,21 +1299,25 @@ async def verify_api_key(
         raise HTTPException(status_code=401, detail="Invalid API key")
     return token
 
+# ═══════════════════════════════════════════════════════════════════════════════
 # ─── FastAPI App ──────────────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     await services.init_db()
     await services.start_cleanup()
+    await zep_memory.init()          # ← تهيئة Zep Cloud
     log(f"gemini-web2api v{__version__} started", "INFO")
+    log(f"Memory: {zep_memory.status()}", "MEM")
     yield
     if services._cleanup_task:
         services._cleanup_task.cancel()
 
 app = FastAPI(
-    title="Gemini Web2API (Agent Edition)",
+    title="Gemini Web2API + Zep Memory (Agent Edition)",
     version=__version__,
-    description="OpenAI-compatible proxy for Google Gemini Web with full Agent/Tool support",
+    description="OpenAI-compatible Gemini proxy with persistent Zep Cloud memory and full Agent Loop",
     lifespan=lifespan,
 )
 
@@ -913,7 +1329,9 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# ═══════════════════════════════════════════════════════════════════════════════
 # ─── /v1/models ───────────────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 @app.get("/v1/models")
 async def list_models():
@@ -930,14 +1348,13 @@ async def list_models():
                     "tool_use": True,
                     "streaming": True,
                     "agent_loop": True,
+                    "persistent_memory": zep_memory.enabled,
                 },
             }
             for name, cfg in MODELS.items()
         ],
     }
 
-# ─── /v1beta/models ───────────────────────────────────────────────────────────
-
 @app.get("/v1beta/models")
 async def google_models_list():
     return {
@@ -952,7 +1369,9 @@ async def google_models_list():
         ]
     }
 
+# ═══════════════════════════════════════════════════════════════════════════════
 # ─── /v1/chat/completions ─────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 @app.post("/v1/chat/completions")
 async def chat_completions(
@@ -960,7 +1379,7 @@ async def chat_completions(
     request: Request,
     _: str = Depends(verify_api_key),
 ):
-    # Rate Limiting
+    # ─── Rate Limiting
     client_ip = request.client.host
     allowed, wait_time = await services.check_rate_limit(client_ip)
     if not allowed:
@@ -970,6 +1389,7 @@ async def chat_completions(
             headers={"Retry-After": str(wait_time)},
         )
 
+    # ─── Model Resolution
     model_name, model_id, think_mode, err = resolve_model(
         body.model or CONFIG["default_model"]
     )
@@ -978,75 +1398,94 @@ async def chat_completions(
 
     tools = body.tools
     messages = [m.dict(exclude_none=True) for m in body.messages]
+    # user_id: نستخدمه كمفتاح للذاكرة — ثابت لكل مستخدم
+    user_id = body.user or client_ip or "default"
+
+    # ═══════════════════════════════════════════════════════
+    # ✅ ZEP: تجهيز الجلسة واسترجاع الذاكرة الكاملة
+    # ═══════════════════════════════════════════════════════
+    await zep_memory.ensure_user_session(user_id)
+
+    last_query = extract_last_user_query(messages)
+
+    # استرجاع الذاكرة والبحث الدلالي بالتوازي
+    memory_context = await zep_memory.get_full_context(user_id, last_query)
+    # ═══════════════════════════════════════════════════════
+
     cid = f"chatcmpl-{uuid.uuid4().hex[:12]}"
     created = int(time.time())
 
-    # Cache key
-    context_str = "".join(f"{m.get('role')}:{m.get('content')}" for m in messages)
+    # Cache key (بدون ذاكرة لأن الذاكرة تتغير)
     cache_key = hashlib.md5(
-        f"{model_name}:{context_str}:{body.user}:{bool(tools)}".encode()
+        f"{model_name}:{user_id}:{last_query[:200]}:{bool(tools)}".encode()
     ).hexdigest()
 
-    # ─── Streaming ───
+    # ─── Streaming ───────────────────────────────────────────
     if body.stream:
         async def stream_gen():
             full_text = ""
+            final_tool_calls = None
             try:
                 if tools:
-                    # ✅ Streaming مع أدوات: نُرسل tool calls كـ chunk خاص
                     loop = asyncio.get_event_loop()
-                    text, tool_calls, _ = await loop.run_in_executor(
+                    text, tc, updated_msgs = await loop.run_in_executor(
                         None, run_agent_sync,
                         messages, model_id, think_mode, tools,
-                        CONFIG["agent_max_iterations"]
+                        memory_context, CONFIG["agent_max_iterations"]
                     )
                     full_text = text or ""
+                    final_tool_calls = tc
 
-                    if tool_calls:
+                    if tc:
                         # إرسال tool calls chunk
-                        msg_delta = {"role": "assistant", "content": full_text or None, "tool_calls": tool_calls}
                         chunk = {
                             "id": cid, "object": "chat.completion.chunk",
                             "created": created, "model": model_name,
-                            "choices": [{"index": 0, "delta": msg_delta, "finish_reason": "tool_calls"}],
+                            "choices": [{
+                                "index": 0,
+                                "delta": {"role": "assistant", "content": full_text or None, "tool_calls": tc},
+                                "finish_reason": "tool_calls",
+                            }],
                         }
                         yield f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
                     else:
-                        # إرسال النص تدريجياً
                         if full_text:
                             chunk = {
                                 "id": cid, "object": "chat.completion.chunk",
                                 "created": created, "model": model_name,
-                                "choices": [{"index": 0, "delta": {"role": "assistant", "content": full_text}, "finish_reason": None}],
+                                "choices": [{
+                                    "index": 0,
+                                    "delta": {"role": "assistant", "content": full_text},
+                                    "finish_reason": None,
+                                }],
                             }
                             yield f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
 
                 else:
                     # Streaming بدون أدوات
-                    prompt = messages_to_prompt(messages)
+                    prompt = messages_to_prompt(messages, memory_context=memory_context)
                     for delta in gemini_stream_iter(prompt, model_id, think_mode):
                         full_text += delta
                         chunk = {
                             "id": cid, "object": "chat.completion.chunk",
                             "created": created, "model": model_name,
-                            "choices": [{"index": 0, "delta": {"content": delta}, "finish_reason": None}],
+                            "choices": [{
+                                "index": 0,
+                                "delta": {"content": delta},
+                                "finish_reason": None,
+                            }],
                         }
                         yield f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
 
                 # Final chunk
-                finish = "tool_calls" if tools and full_text else "stop"
-                final_chunk = {
-                    "id": cid, "object": "chat.completion.chunk",
-                    "created": created, "model": model_name,
-                    "choices": [{"index": 0, "delta": {}, "finish_reason": finish}],
-                }
-                yield f"data: {json.dumps(final_chunk)}\n\n"
+                finish = "tool_calls" if final_tool_calls else "stop"
+                yield f"data: {json.dumps({'id': cid, 'object': 'chat.completion.chunk', 'created': created, 'model': model_name, 'choices': [{'index': 0, 'delta': {}, 'finish_reason': finish}]})}\n\n"
                 yield "data: [DONE]\n\n"
 
-                # Cache النص النهائي (بدون tool calls)
-                if full_text and not tools:
-                    resp_data = _build_completion_response(cid, created, model_name, full_text, None, "")
-                    await services.set_cache(cache_key, json.dumps(resp_data))
+                # ✅ ZEP: حفظ المحادثة بعد الانتهاء
+                if full_text and not final_tool_calls:
+                    save_msgs = [m for m in messages if m.get("role") in ("user", "assistant", "tool")]
+                    await zep_memory.save_turn(user_id, save_msgs, full_text)
 
             except Exception as e:
                 log(f"Stream error: {e}", "ERROR")
@@ -1054,8 +1493,8 @@ async def chat_completions(
 
         return StreamingResponse(stream_gen(), media_type="text/event-stream")
 
-    # ─── Non-streaming ───
-    # Cache (فقط بدون أدوات)
+    # ─── Non-streaming ────────────────────────────────────────
+    # Cache (بدون أدوات فقط)
     if not tools:
         cached = await services.get_cache(cache_key)
         if cached:
@@ -1064,52 +1503,37 @@ async def chat_completions(
     try:
         loop = asyncio.get_event_loop()
         if tools:
-            # ✅ استخدم Agent Loop
-            text, tool_calls, _ = await loop.run_in_executor(
+            text, tool_calls, updated_msgs = await loop.run_in_executor(
                 None, run_agent_sync,
                 messages, model_id, think_mode, tools,
-                CONFIG["agent_max_iterations"]
+                memory_context, CONFIG["agent_max_iterations"]
             )
         else:
-            prompt = messages_to_prompt(messages)
+            prompt = messages_to_prompt(messages, memory_context=memory_context)
             text, tool_calls = await loop.run_in_executor(
-                None, call_gemini_sync, prompt, model_id, think_mode, None
+                None, call_gemini_sync,
+                prompt, model_id, think_mode, None
             )
     except Exception as e:
         log(f"Error: {e}", "ERROR")
         raise HTTPException(status_code=502, detail=f"Upstream error: {e}")
 
+    # ✅ ZEP: حفظ المحادثة
+    if text and not tool_calls:
+        save_msgs = [m for m in messages if m.get("role") in ("user", "assistant", "tool")]
+        await zep_memory.save_turn(user_id, save_msgs, text)
+
     prompt_text = messages_to_prompt(messages)
     resp_data = _build_completion_response(cid, created, model_name, text, tool_calls, prompt_text)
 
-    if not tools:
+    if not tools and text:
         await services.set_cache(cache_key, json.dumps(resp_data))
 
     return JSONResponse(content=resp_data)
 
-
-def _build_completion_response(
-    cid: str, created: int, model: str, text: str,
-    tool_calls: Optional[list], prompt: str = ""
-) -> dict:
-    msg = {"role": "assistant", "content": text or None}
-    if tool_calls:
-        msg["tool_calls"] = tool_calls
-    finish = "tool_calls" if tool_calls else "stop"
-    return {
-        "id": cid,
-        "object": "chat.completion",
-        "created": created,
-        "model": model,
-        "choices": [{"index": 0, "message": msg, "finish_reason": finish}],
-        "usage": {
-            "prompt_tokens": len(prompt) // 4,
-            "completion_tokens": len(text) // 4 if text else 0,
-            "total_tokens": (len(prompt) + len(text)) // 4 if text else len(prompt) // 4,
-        },
-    }
-
+# ═══════════════════════════════════════════════════════════════════════════════
 # ─── /v1/responses (Codex CLI / Responses API) ────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 @app.post("/v1/responses")
 async def responses_api(
@@ -1126,6 +1550,7 @@ async def responses_api(
     input_items = req.get("input", [])
     tools = req.get("tools")
     messages = []
+    user_id = req.get("user", "default")
 
     if req.get("instructions"):
         messages.append({"role": "system", "content": req["instructions"]})
@@ -1197,21 +1622,32 @@ async def responses_api(
     if not any(m.get("content") for m in messages):
         raise HTTPException(status_code=400, detail="Empty input")
 
+    # ✅ Zep Memory
+    await zep_memory.ensure_user_session(user_id)
+    last_query = extract_last_user_query(messages)
+    memory_context = await zep_memory.get_full_context(user_id, last_query)
+
     loop = asyncio.get_event_loop()
     try:
         if tools:
             text, tool_calls, _ = await loop.run_in_executor(
-                None, run_agent_sync, messages, model_id, think_mode, tools,
-                CONFIG["agent_max_iterations"]
+                None, run_agent_sync,
+                messages, model_id, think_mode, tools,
+                memory_context, CONFIG["agent_max_iterations"]
             )
         else:
-            prompt = messages_to_prompt(messages)
+            prompt = messages_to_prompt(messages, memory_context=memory_context)
             text, tool_calls = await loop.run_in_executor(
                 None, call_gemini_sync, prompt, model_id, think_mode, None
             )
     except Exception as e:
         raise HTTPException(status_code=502, detail=f"Upstream error: {e}")
 
+    # ✅ حفظ في Zep
+    if text and not tool_calls:
+        save_msgs = [m for m in messages if m.get("role") in ("user", "assistant", "tool")]
+        await zep_memory.save_turn(user_id, save_msgs, text)
+
     rid = f"resp_{uuid.uuid4().hex[:16]}"
     mid = f"msg_{uuid.uuid4().hex[:12]}"
     output = []
@@ -1236,6 +1672,7 @@ async def responses_api(
         })
 
     prompt_text = messages_to_prompt(messages)
+
     if req.get("stream"):
         async def responses_stream():
             yield f"event: response.created\ndata: {json.dumps({'type': 'response.created', 'response': {'id': rid, 'object': 'response', 'status': 'in_progress', 'model': model_name, 'output': []}})}\n\n"
@@ -1268,38 +1705,44 @@ async def responses_api(
         },
     })
 
+# ═══════════════════════════════════════════════════════════════════════════════
 # ─── Google Native API /v1beta ────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
-def _google_contents_to_prompt(req: dict) -> str:
-    parts = []
+def _google_contents_to_messages(req: dict) -> list:
+    messages = []
     sys_inst = req.get("systemInstruction")
     if sys_inst:
         sys_text = " ".join(p.get("text", "") for p in sys_inst.get("parts", []) if p.get("text"))
         if sys_text:
-            parts.append(f"[SYSTEM]\n{sys_text}")
+            messages.append({"role": "system", "content": sys_text})
     for content in req.get("contents", []):
-        role = content.get("role", "user")
+        role = "assistant" if content.get("role") == "model" else "user"
         text = " ".join(p.get("text", "") for p in content.get("parts", []) if p.get("text"))
-        if role == "model":
-            parts.append(f"[ASSISTANT]: {text}")
-        else:
-            parts.append(f"[USER]: {text}")
-    return "\n\n".join(p for p in parts if p)
+        messages.append({"role": role, "content": text})
+    return messages
 
 @app.post("/v1beta/models/{model_path:path}")
 async def google_generate(model_path: str, request: Request):
     req = await request.json()
     model_name_raw = model_path.split(":")[0]
-    stream = ":streamGenerateContent" in model_path
+    is_stream = ":streamGenerateContent" in model_path
 
     model_name, model_id, think_mode, err = resolve_model(model_name_raw)
     if err:
         raise HTTPException(status_code=400, detail=err)
 
-    prompt = _google_contents_to_prompt(req)
-    if not prompt.strip():
+    messages = _google_contents_to_messages(req)
+    if not messages:
         raise HTTPException(status_code=400, detail="Empty content")
 
+    # Zep للـ Google API أيضاً
+    user_id = req.get("user", "google_api")
+    await zep_memory.ensure_user_session(user_id)
+    last_query = extract_last_user_query(messages)
+    memory_context = await zep_memory.get_full_context(user_id, last_query)
+
+    prompt = messages_to_prompt(messages, memory_context=memory_context)
     loop = asyncio.get_event_loop()
     try:
         text, _ = await loop.run_in_executor(
@@ -1308,6 +1751,9 @@ async def google_generate(model_path: str, request: Request):
     except Exception as e:
         raise HTTPException(status_code=502, detail=f"Upstream error: {e}")
 
+    if text:
+        await zep_memory.save_turn(user_id, messages, text)
+
     candidate = {
         "content": {"parts": [{"text": text or ""}], "role": "model"},
         "finishReason": "STOP",
@@ -1323,14 +1769,16 @@ async def google_generate(model_path: str, request: Request):
         "modelVersion": model_name,
     }
 
-    if stream:
+    if is_stream:
         async def google_stream():
             yield f"data: {json.dumps(response_obj)}\n\n"
         return StreamingResponse(google_stream(), media_type="text/event-stream")
 
     return JSONResponse(response_obj)
 
+# ═══════════════════════════════════════════════════════════════════════════════
 # ─── Health & Root ────────────��───────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 @app.get("/")
 async def root():
@@ -1338,24 +1786,77 @@ async def root():
         "service": "gemini-web2api",
         "version": __version__,
         "models": list(MODELS.keys()),
+        "memory": zep_memory.status(),
         "features": {
+            "persistent_memory": zep_memory.enabled,
             "agent_loop": True,
             "tool_calling": True,
             "streaming": True,
             "cache": True,
             "rate_limiting": True,
         },
-        "endpoints": ["/v1/chat/completions", "/v1/models", "/v1/responses", "/v1beta/models"],
+        "endpoints": [
+            "/v1/chat/completions",
+            "/v1/models",
+            "/v1/responses",
+            "/v1beta/models",
+            "/health",
+            "/memory/status",
+        ],
     }
 
 @app.get("/health")
 async def health():
-    return {"status": "healthy", "timestamp": time.time(), "version": __version__}
+    return {
+        "status": "healthy",
+        "timestamp": time.time(),
+        "version": __version__,
+        "memory_enabled": zep_memory.enabled,
+    }
 
+@app.get("/memory/status")
+async def memory_status():
+    """حالة الذاكرة الدائمة."""
+    return {
+        "provider": "Zep Cloud",
+        "enabled": zep_memory.enabled,
+        "config": {
+            "memory_type": CONFIG.get("zep_memory_type"),
+            "recent_messages": CONFIG.get("zep_recent_messages"),
+            "search_limit": CONFIG.get("zep_search_limit"),
+            "min_fact_rating": CONFIG.get("zep_min_fact_rating"),
+        },
+        "error": zep_memory._init_error if not zep_memory.enabled else None,
+    }
+
+@app.post("/memory/add-fact")
+async def add_fact_endpoint(
+    request: Request,
+    _: str = Depends(verify_api_key),
+):
+    """إضافة حقيقة صريحة لذاكرة مستخدم محدد."""
+    body = await request.json()
+    user_id = body.get("user_id", "default")
+    fact = body.get("fact", "")
+    if not fact:
+        raise HTTPException(status_code=400, detail="fact is required")
+
+    await zep_memory.ensure_user_session(user_id)
+    await zep_memory.add_fact(user_id, fact)
+    return {"status": "ok", "fact": fact, "user_id": user_id}
+
+# ═══════════════════════════════════════════════════════════════════════════════
 # ─── Gradio UI ────────────────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
 
 def build_gradio_interface():
-    async def chat_handler(message: str, history: list, model_choice: str, request: gr.Request):
+    async def chat_handler(
+        message: str,
+        history: list,
+        model_choice: str,
+        user_id_box: str,
+        request: gr.Request,
+    ):
         if not message or not message.strip():
             yield history
             return
@@ -1366,71 +1867,121 @@ def build_gradio_interface():
             yield history
             return
 
-        history.append((message, ""))
+        uid = (user_id_box or "").strip() or (request.client.host if request.client else "default")
+
+        # تجهيز الجلسة واسترجاع الذاكرة
+        await zep_memory.ensure_user_session(uid)
+        memory_context = await zep_memory.get_full_context(uid, message)
+
+        history.append((message, "⏳ ..."))
         yield history
 
         full_response = ""
         try:
-            prompt = messages_to_prompt([{"role": "user", "content": message}])
+            msgs = [{"role": "user", "content": message}]
+            prompt = messages_to_prompt(msgs, memory_context=memory_context)
+
             for chunk in gemini_stream_iter(prompt, model_id, think_mode):
                 full_response += chunk
                 history[-1] = (message, full_response)
                 yield history
+
         except Exception as e:
             full_response = f"❌ Error: {e}"
             history[-1] = (message, full_response)
             yield history
+            return
 
-    api_endpoint = "https://your-space.hf.space/v1"
+        # حفظ في Zep
+        if full_response:
+            await zep_memory.save_turn(
+                uid,
+                [{"role": "user", "content": message}],
+                full_response,
+            )
+            log(f"Saved chat turn to Zep for user={uid}", "MEM")
+
+    mem_status = "✅ Zep Cloud متصل" if HAS_ZEP else "❌ zep-cloud غير مثبّت"
     api_key_display = CONFIG.get("api_keys", ["sk-gemini"])[0]
 
-    with gr.Blocks(title="Gemini Web2API — Agent Edition") as demo:
+    with gr.Blocks(
+        title="Gemini Agent + Zep Memory",
+        theme=gr.themes.Soft(),
+    ) as demo:
         gr.Markdown(f"""
-        # 🤖 Gemini Web2API — Agent Edition v{__version__}
-        > OpenAI-compatible proxy مع دعم كامل لـ Agent Loop وTool Calling
-
-        | | |
-        |---|---|
-        | **Base URL** | `{api_endpoint}` |
-        | **API Key** | `{api_key_display}` |
-        | **Models** | {', '.join(f'`{m}`' for m in MODELS.keys())} |
-        | **Agent Loop** | ✅ حتى {CONFIG['agent_max_iterations']} iterations |
+# 🤖 Gemini Professional Agent + 🧠 Zep Persistent Memory
+### v{__version__} — ذاكرة دائمة عبر كل الجلسات
+
+| الخاصية | القيمة |
+|---------|--------|
+| **Memory** | {mem_status} |
+| **Agent Loop** | ✅ حتى {CONFIG['agent_max_iterations']} iterations |
+| **API Key** | `{api_key_display}` |
+| **Base URL** | `/v1` |
         """)
 
         with gr.Row():
             with gr.Column(scale=4):
-                chatbot = gr.Chatbot(height=500, label="المحادثة")
+                chatbot = gr.Chatbot(
+                    height=520,
+                    label="المحادثة — تُحفظ تلقائياً في Zep",
+                    show_copy_button=True,
+                )
             with gr.Column(scale=1):
-                gr.Markdown("""### ✅ المميزات
-- Agent Loop (ReAct)
+                gr.Markdown("""
+### 🧠 الذاكرة الدائمة
+يتذكر الوكيل عبر **كل الجلسات**:
+- الحقائق المستخرجة تلقائياً
+- ملخص كامل للمحادثات
+- آخر 20 رسالة بالتفصيل
+- بحث دلالي في كل التاريخ
+
+### ✅ المميزات
+- يتذكر تغييرات الموضوع
+- يحفظ تفاصيل المهام
+- Agent Loop احترافي
 - Tool Calling موثوق
-- JSON Parser متعدد المستويات
 - Streaming حقيقي
-- SQLite Cache
-- Rate Limiting
-- Retry Logic
-- Fallback للنموذج الافتراضي
                 """)
 
         with gr.Row():
-            msg_box = gr.Textbox(label="رسالتك", placeholder="اكتب هنا...", lines=2, scale=5)
-            send_btn = gr.Button("إرسال ▶", variant="primary", scale=1)
-
-        with gr.Row():
-            clear_btn = gr.Button("🗑️ مسح")
+            user_id_box = gr.Textbox(
+                label="🆔 User ID (اختياري — للتمييز بين المستخدمين)",
+                placeholder="مثال: user_123 أو اتركه فارغاً",
+                scale=2,
+            )
             model_dd = gr.Dropdown(
                 choices=list(MODELS.keys()),
                 value=CONFIG["default_model"],
-                label="النموذج",
+                label="🤖 النموذج",
                 scale=2,
             )
 
-        msg_box.submit(chat_handler, [msg_box, chatbot, model_dd], [chatbot]).then(
-            lambda: "", None, [msg_box]
-        )
-        send_btn.click(chat_handler, [msg_box, chatbot, model_dd], [chatbot]).then(
-            lambda: "", None, [msg_box]
-        )
+        with gr.Row():
+            msg_box = gr.Textbox(
+                label="رسالتك",
+                placeholder="اكتب هنا... يمكنك تغيير الموضوع في أي وقت، الوكيل يتذكر كل شيء ✨",
+                lines=3,
+                scale=5,
+            )
+            send_btn = gr.Button("إرسال ▶", variant="primary", scale=1)
+
+        with gr.Row():
+            clear_btn = gr.Button("🗑️ مسح العرض (لا يمسح الذاكرة)")
+
+        # ربط الأحداث
+        msg_box.submit(
+            chat_handler,
+            [msg_box, chatbot, model_dd, user_id_box],
+            [chatbot],
+        ).then(lambda: "", None, [msg_box])
+
+        send_btn.click(
+            chat_handler,
+            [msg_box, chatbot, model_dd, user_id_box],
+            [chatbot],
+        ).then(lambda: "", None, [msg_box])
+
         clear_btn.click(lambda: [], None, [chatbot])
 
     return demo
@@ -1438,17 +1989,20 @@ def build_gradio_interface():
 demo = build_gradio_interface()
 app = gr.mount_gradio_app(app, demo, path="/chat")
 
+# ═══════════════════════════════════════════════════════════════════════════════
 # ─── Entry Point ──────────────────────────────────────────────────────────────
+# ════════��══════════════════════════════════════════════════════════════════════
 
 if __name__ == "__main__":
     import uvicorn
 
-    parser = argparse.ArgumentParser(description="Gemini Web2API Agent Edition")
+    parser = argparse.ArgumentParser(description="Gemini Web2API + Zep Memory Agent")
     parser.add_argument("--port", type=int, default=CONFIG["port"])
     parser.add_argument("--host", type=str, default=CONFIG["host"])
     parser.add_argument("--cookie-file", type=str, default=None)
     parser.add_argument("--proxy", type=str, default=None)
     parser.add_argument("--max-iterations", type=int, default=CONFIG["agent_max_iterations"])
+    parser.add_argument("--zep-key", type=str, default=None, help="Zep Cloud API Key")
     parser.add_argument("--version", action="version", version=f"v{__version__}")
     args = parser.parse_args()
 
@@ -1456,18 +2010,23 @@ if __name__ == "__main__":
         CONFIG["cookie_file"] = args.cookie_file
     if args.proxy:
         CONFIG["proxy"] = args.proxy
+    if args.zep_key:
+        CONFIG["zep_api_key"] = args.zep_key
     CONFIG["agent_max_iterations"] = args.max_iterations
 
-    print(f"\n{'='*60}")
-    print(f"  gemini-web2api v{__version__} — Agent Edition")
-    print(f"{'='*60}")
+    print(f"\n{'═'*65}")
+    print(f"  gemini-web2api v{__version__} — Professional Agent + Zep Memory")
+    print(f"{'═'*65}")
     print(f"  API:          http://localhost:{args.port}/v1")
     print(f"  Chat UI:      http://localhost:{args.port}/chat")
+    print(f"  Health:       http://localhost:{args.port}/health")
+    print(f"  Memory:       http://localhost:{args.port}/memory/status")
     print(f"  Models:       {', '.join(MODELS.keys())}")
     print(f"  Agent Loop:   max {CONFIG['agent_max_iterations']} iterations")
+    print(f"  Zep Memory:   {'✅ Key configured' if CONFIG.get('zep_api_key') else '❌ ZEP_API_KEY not set'}")
     print(f"  Cookie:       {'✅' if CONFIG.get('cookie_file') or CONFIG.get('_cookie_inline') else '❌ none (anonymous)'}")
     print(f"  Proxy:        {CONFIG.get('proxy') or '❌ none'}")
-    print(f"{'='*60}\n")
+    print(f"{'═'*65}\n")
 
     uvicorn.run(
         app,