Update app.py

app.py

@@ -2901,4 +2901,945 @@ async def simple_chat_stream(chat_req: ChatRequest, request: Request):
             "Connection": "keep-alive",
             "X-Accel-Buffering": "no",
         }
+    )
+    # =====================================================
+# BACKGROUND CLEANUP TASK
+# =====================================================
+async def cleanup_task():
+    """مهمة تنظيف دورية للجلسات القديمة"""
+    while True:
+        try:
+            await asyncio.sleep(3600)  # كل ساعة
+            CONTEXT_STORE.cleanup_old_sessions(max_age_hours=24)
+            logger.info("[Cleanup] Old sessions cleaned")
+        except Exception as e:
+            logger.error(f"[Cleanup] Error: {e}")
+
+@app.on_event("startup")
+async def startup_event():
+    """تشغيل المهام عند بدء التطبيق"""
+    asyncio.create_task(cleanup_task())
+    logger.info("=" * 60)
+    logger.info("🚀 G4F Execution Engine v6.0.0 Started")
+    logger.info(f"🍪 Cookies: {COOKIE_STATUS}")
+    logger.info(f"🔌 Providers: {list(REAL_PROVIDERS.keys())}")
+    logger.info("🔧 Execution Engine: ACTIVE")
+    logger.info("✅ Problems Fixed:")
+    logger.info("   1. Smart Watcher Syndrome → ResponseAnalyzer")
+    logger.info("   2. Lost in Translation → JSON Cleaner")
+    logger.info("   3. Missing Final Push → ExecutionEnforcer")
+    logger.info("   4. Identity Confusion → EXECUTOR mode")
+    logger.info("=" * 60)
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """تنظيف عند إغلاق التطبيق"""
+    logger.info("[Shutdown] G4F Execution Engine stopping...")
+    active_sessions = len(CONTEXT_STORE._store)
+    logger.info(f"[Shutdown] Active sessions at shutdown: {active_sessions}")
+
+# =====================================================
+# نقطة تشخيص: عرض حالة النظام الكاملة
+# =====================================================
+@app.get("/debug/system-status")
+async def debug_system_status(request: Request):
+    """عرض حالة النظام الكاملة للتشخيص"""
+    verify_api_key(request)
+
+    # إحصائيات الجلسات
+    session_stats = {
+        "total_sessions": 0,
+        "sessions_with_pending_tools": 0,
+        "sessions_with_description_failures": 0,
+        "sessions_completed": 0,
+        "total_tool_executions": 0,
+        "total_description_failures": 0,
+    }
+
+    with CONTEXT_STORE._lock:
+        session_stats["total_sessions"] = len(CONTEXT_STORE._store)
+        for sid, ctx in CONTEXT_STORE._store.items():
+            pending = len(ctx.get("pending_tool_calls", []))
+            desc_failures = ctx.get("consecutive_description_count", 0)
+            executed = len(ctx.get("executed_tool_calls", []))
+            state = ctx.get("current_state", "")
+
+            if pending > 0:
+                session_stats["sessions_with_pending_tools"] += 1
+            if desc_failures > 0:
+                session_stats["sessions_with_description_failures"] += 1
+            if state == ExecutionState.COMPLETED:
+                session_stats["sessions_completed"] += 1
+
+            session_stats["total_tool_executions"] += executed
+            session_stats["total_description_failures"] += desc_failures
+
+    # إحصائيات المزودين
+    provider_stats = {}
+    for pname, pobj in REAL_PROVIDERS.items():
+        models = discover_provider_models(pobj, pname)
+        provider_stats[pname] = {
+            "available": True,
+            "model_count": len(models),
+            "models": models[:3],  # أول 3 نماذج فقط
+        }
+
+    # إحصائيات محرك التنفيذ
+    engine_stats = {
+        "description_patterns_count": len(ResponseAnalyzer.DESCRIPTION_PHRASES),
+        "tool_call_start_markers": len(ToolCallParser.START_MARKERS),
+        "max_execution_retries": ExecutionEnforcer.MAX_EXECUTION_RETRIES,
+        "cache_size": len(CACHE.cache),
+        "cache_max_size": CACHE.max_size,
+        "cache_ttl_seconds": CACHE.ttl,
+    }
+
+    return {
+        "status": "operational",
+        "version": "6.0.0",
+        "uptime_info": {
+            "cookie_status": COOKIE_STATUS,
+            "providers_loaded": len(REAL_PROVIDERS),
+        },
+        "session_statistics": session_stats,
+        "provider_statistics": provider_stats,
+        "execution_engine_statistics": engine_stats,
+        "execution_states": {
+            "IDLE": ExecutionState.IDLE,
+            "PLANNING": ExecutionState.PLANNING,
+            "TOOL_PENDING": ExecutionState.TOOL_PENDING,
+            "TOOL_EXECUTING": ExecutionState.TOOL_EXECUTING,
+            "TOOL_DONE": ExecutionState.TOOL_DONE,
+            "AWAITING_NEXT": ExecutionState.AWAITING_NEXT,
+            "COMPLETED": ExecutionState.COMPLETED,
+        },
+        "timestamp": int(time.time())
+    }
+
+# =====================================================
+# نقطة تشخيص: اختبار مزود محدد
+# =====================================================
+@app.post("/debug/test-provider")
+async def debug_test_provider(request: Request):
+    """اختبار مزود محدد بشكل مباشر"""
+    verify_api_key(request)
+    body = await request.json()
+    provider_name = body.get("provider", "Blackbox")
+    model_name = body.get("model", "gpt-4o")
+    test_message = body.get("message", "Say 'hello' in one word.")
+    timeout_seconds = body.get("timeout", 30)
+
+    pobj = REAL_PROVIDERS.get(provider_name)
+    if not pobj:
+        return {
+            "success": False,
+            "error": f"Provider '{provider_name}' not found",
+            "available_providers": list(REAL_PROVIDERS.keys())
+        }
+
+    start_time = time.time()
+    response_chunks = []
+    error_msg = None
+
+    try:
+        msgs = [{"role": "user", "content": test_message}]
+        stream = g4f.ChatCompletion.create(
+            model=model_name,
+            provider=pobj,
+            messages=msgs,
+            stream=True,
+            timeout=timeout_seconds
+        )
+
+        for chunk in stream:
+            c = clean_stream(chunk)
+            if c:
+                response_chunks.append(c)
+                # توقف بعد 500 حرف للاختبار
+                if sum(len(r) for r in response_chunks) > 500:
+                    break
+
+    except Exception as e:
+        error_msg = str(e)
+
+    elapsed = time.time() - start_time
+    full_response = "".join(response_chunks)
+
+    return {
+        "success": bool(full_response and not error_msg),
+        "provider": provider_name,
+        "model": model_name,
+        "test_message": test_message,
+        "response_preview": full_response[:300] if full_response else "",
+        "response_length": len(full_response),
+        "elapsed_seconds": round(elapsed, 2),
+        "error": error_msg,
+        "timestamp": int(time.time())
+    }
+
+# =====================================================
+# نقطة تشخيص: اختبار دورة كاملة مع أداة
+# =====================================================
+@app.post("/debug/test-full-tool-cycle")
+async def debug_test_full_tool_cycle(request: Request):
+    """
+    اختبار دورة كاملة: رسالة → كشف أداة → تنفيذ → نتيجة
+    يُظهر بوضوح هل المحرك يعمل أم لا
+    """
+    verify_api_key(request)
+    body = await request.json()
+    test_message = body.get(
+        "message",
+        "Create a file called 'hello.py' with content: print('Hello World')"
+    )
+    model = body.get("model", "gpt-4o")
+
+    test_tools = [
+        {
+            "name": "write_file",
+            "description": "Write content to a file on disk",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "The file path to write to"
+                    },
+                    "content": {
+                        "type": "string",
+                        "description": "The content to write to the file"
+                    }
+                },
+                "required": ["path", "content"]
+            }
+        }
+    ]
+
+    test_session = f"test_cycle_{uuid.uuid4().hex[:8]}"
+    results = {
+        "test_session": test_session,
+        "test_message": test_message,
+        "model": model,
+        "steps": [],
+        "final_tool_calls": [],
+        "success": False,
+        "description_attempts": 0,
+        "execution_attempts": 0,
+    }
+
+    # المرحلة 1: تحويل الرسالة
+    messages = [{"role": "user", "content": test_message}]
+    full_message, history = MessageConverter.convert_messages(
+        messages, "", test_tools, "auto", test_session
+    )
+
+    results["steps"].append({
+        "step": 1,
+        "name": "Message Conversion",
+        "message_length": len(full_message),
+        "has_tool_instructions": "tool_call" in full_message.lower(),
+        "has_executor_rule": "EXECUTOR" in full_message,
+    })
+
+    # المرحلة 2: إرسال للنموذج
+    step2_start = time.time()
+    full_response = ""
+    try:
+        for chunk in ask(
+            full_message, history, "Blackbox", model,
+            tools=test_tools, session_id=test_session
+        ):
+            full_response += chunk
+    except Exception as e:
+        results["steps"].append({
+            "step": 2,
+            "name": "Model Request",
+            "error": str(e)
+        })
+        return results
+
+    step2_elapsed = time.time() - step2_start
+
+    # المرحلة 3: تحليل الرد
+    analysis = ResponseAnalyzer.analyze(full_response, test_tools)
+    clean_text, tool_calls = ToolCallParser.parse_tool_calls(full_response, test_tools)
+
+    results["steps"].append({
+        "step": 2,
+        "name": "Model Request",
+        "response_length": len(full_response),
+        "response_preview": full_response[:200],
+        "elapsed_seconds": round(step2_elapsed, 2),
+        "has_actual_tool_call": analysis["has_actual_tool_call"],
+        "has_description_without_execution": analysis["has_description_without_execution"],
+        "tool_calls_found": len(tool_calls),
+        "described_actions": analysis["described_actions"][:3],
+        "intended_tool": analysis.get("intended_tool_name"),
+    })
+
+    if analysis["has_description_without_execution"]:
+        results["description_attempts"] += 1
+
+    # المرحلة 4: تطبيق محرك التنفيذ إذا لزم
+    if not tool_calls and analysis["has_description_without_execution"]:
+        enforcement = ExecutionEnforcer.post_process_response(
+            full_response, test_session, test_tools, tool_calls
+        )
+
+        results["steps"].append({
+            "step": 3,
+            "name": "Execution Enforcer",
+            "needs_retry": enforcement["needs_retry"],
+            "retry_message_preview": enforcement["retry_message"][:200],
+        })
+
+        if enforcement["needs_retry"]:
+            results["execution_attempts"] += 1
+            retry_response = ""
+            retry_start = time.time()
+
+            try:
+                for chunk in ask(
+                    enforcement["retry_message"], [], "Blackbox", model,
+                    tools=test_tools, session_id=test_session
+                ):
+                    retry_response += chunk
+            except Exception as e:
+                results["steps"].append({
+                    "step": 4,
+                    "name": "Retry Request",
+                    "error": str(e)
+                })
+
+            retry_elapsed = time.time() - retry_start
+            clean_text2, tool_calls2 = ToolCallParser.parse_tool_calls(
+                retry_response, test_tools
+            )
+
+            results["steps"].append({
+                "step": 4,
+                "name": "Retry Request",
+                "response_length": len(retry_response),
+                "response_preview": retry_response[:200],
+                "elapsed_seconds": round(retry_elapsed, 2),
+                "tool_calls_found": len(tool_calls2),
+            })
+
+            if tool_calls2:
+                tool_calls = tool_calls2
+
+    # النتيجة النهائية
+    results["final_tool_calls"] = tool_calls
+    results["success"] = len(tool_calls) > 0
+
+    # تنظيف الجلسة التجريبية
+    with CONTEXT_STORE._lock:
+        if test_session in CONTEXT_STORE._store:
+            del CONTEXT_STORE._store[test_session]
+
+    results["summary"] = {
+        "total_steps": len(results["steps"]),
+        "description_attempts": results["description_attempts"],
+        "execution_attempts": results["execution_attempts"],
+        "tool_calls_extracted": len(results["final_tool_calls"]),
+        "verdict": (
+            "✅ SUCCESS: Tool was actually called"
+            if results["success"]
+            else "❌ FAILURE: Model described but didn't execute"
+        )
+    }
+
+    return results
+
+# =====================================================
+# نقطة: مسح كل الجلسات (للتطوير فقط)
+# =====================================================
+@app.delete("/context/all/clear")
+async def clear_all_sessions(request: Request):
+    """مسح جميع الجلسات - للتطوير فقط"""
+    verify_api_key(request)
+    with CONTEXT_STORE._lock:
+        count = len(CONTEXT_STORE._store)
+        CONTEXT_STORE._store.clear()
+    return {
+        "message": f"Cleared {count} sessions",
+        "timestamp": int(time.time())
+    }
+
+# =====================================================
+# نقطة: إضافة نتيجة أداة يدوياً (للاختبار)
+# =====================================================
+@app.post("/context/{session_id}/add-tool-result")
+async def add_tool_result_manually(
+    session_id: str,
+    request: Request
+):
+    """إضافة نتيجة أداة يدوياً - مفيد للاختبار"""
+    verify_api_key(request)
+    body = await request.json()
+    tool_name = body.get("tool_name", "unknown")
+    tool_id = body.get("tool_id", ToolCallParser.generate_tool_id())
+    result = body.get("result", "")
+
+    CONTEXT_STORE.add_tool_result(session_id, tool_name, tool_id, result)
+
+    return {
+        "message": f"Tool result added for session {session_id}",
+        "tool_name": tool_name,
+        "tool_id": tool_id,
+        "result_preview": result[:100],
+        "session_state": CONTEXT_STORE.get_or_create_session(session_id).get(
+            "current_state", ExecutionState.IDLE
+        )
+    }
+
+# =====================================================
+# نقطة: تحديث حالة الجلسة يدوياً
+# =====================================================
+@app.post("/context/{session_id}/set-state")
+async def set_session_state(session_id: str, request: Request):
+    """تحديث حالة الجلسة يدوياً"""
+    verify_api_key(request)
+    body = await request.json()
+    new_state = body.get("state", ExecutionState.IDLE)
+    next_action = body.get("next_required_action", "")
+
+    valid_states = [
+        ExecutionState.IDLE,
+        ExecutionState.PLANNING,
+        ExecutionState.TOOL_PENDING,
+        ExecutionState.TOOL_EXECUTING,
+        ExecutionState.TOOL_DONE,
+        ExecutionState.AWAITING_NEXT,
+        ExecutionState.COMPLETED,
+    ]
+
+    if new_state not in valid_states:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid state. Valid states: {valid_states}"
+        )
+
+    CONTEXT_STORE.update_session(
+        session_id,
+        current_state=new_state,
+        next_required_action=next_action
+    )
+
+    return {
+        "message": f"Session {session_id} state updated",
+        "new_state": new_state,
+        "next_required_action": next_action,
+        "execution_directive": CONTEXT_STORE.get_execution_directive(session_id)
+    }
+
+# =====================================================
+# نقطة: تسجيل أداة معلّقة يدوياً
+# =====================================================
+@app.post("/context/{session_id}/register-pending-tool")
+async def register_pending_tool_manually(
+    session_id: str,
+    request: Request
+):
+    """تسجيل أداة معلّقة يدوياً - لإجبار البوت على تنفيذها"""
+    verify_api_key(request)
+    body = await request.json()
+    tool_name = body.get("name", "")
+    tool_args = body.get("arguments", {})
+    reason = body.get("reason", "Manually registered")
+
+    if not tool_name:
+        raise HTTPException(status_code=400, detail="Tool name is required")
+
+    tool_id = ToolCallParser.generate_tool_id()
+    pending_tool = PendingToolCall(
+        name=tool_name,
+        arguments=tool_args,
+        tool_id=tool_id,
+        reason=reason
+    )
+
+    CONTEXT_STORE.register_pending_tool(session_id, pending_tool)
+
+    return {
+        "message": f"Pending tool '{tool_name}' registered for session {session_id}",
+        "tool_id": tool_id,
+        "directive": CONTEXT_STORE.get_execution_directive(session_id)
+    }
+
+# =====================================================
+# نقطة: اختبار JSON cleaner
+# =====================================================
+@app.post("/debug/test-json-cleaner")
+async def debug_test_json_cleaner(request: Request):
+    """اختبار مُصلح JSON على حالات شائعة"""
+    verify_api_key(request)
+
+    test_cases = [
+        {
+            "name": "Trailing comma",
+            "input": '{"name": "write_file", "arguments": {"path": "test.py",}}',
+            "expected_valid": True
+        },
+        {
+            "name": "Curly quotes",
+            "input": '{\u201cname\u201d: \u201cwrite_file\u201d, \u201carguments\u201d: {}}',
+            "expected_valid": True
+        },
+        {
+            "name": "Missing closing brace",
+            "input": '{"name": "write_file", "arguments": {"path": "test.py"',
+            "expected_valid": True
+        },
+        {
+            "name": "Valid JSON",
+            "input": '{"name": "read_file", "arguments": {"path": "config.json"}}',
+            "expected_valid": True
+        },
+        {
+            "name": "Double trailing commas",
+            "input": '{"name": "tool",, "arguments": {}}',
+            "expected_valid": False  # هذا صعب الإصلاح
+        },
+    ]
+
+    results = []
+    for tc in test_cases:
+        cleaned = ToolCallParser._clean_json_string(tc["input"])
+        parse_success = False
+        parse_result = None
+        error_msg = None
+
+        try:
+            parse_result = json.loads(cleaned)
+            parse_success = True
+        except json.JSONDecodeError as e:
+            error_msg = str(e)
+            # محاولة الإصلاح التلقائي
+            fixed = ToolCallParser._try_fix_json(tc["input"])
+            if fixed:
+                parse_result = fixed
+                parse_success = True
+                error_msg = None
+
+        results.append({
+            "test_name": tc["name"],
+            "original_input": tc["input"],
+            "cleaned_output": cleaned,
+            "parse_success": parse_success,
+            "parse_result": parse_result,
+            "error": error_msg,
+            "expected_valid": tc["expected_valid"],
+            "passed": parse_success == tc["expected_valid"]
+        })
+
+    passed = sum(1 for r in results if r["passed"])
+    return {
+        "test_results": results,
+        "summary": {
+            "passed": passed,
+            "failed": len(results) - passed,
+            "total": len(results)
+        }
+    }
+
+# =====================================================
+# نقطة: اختبار ResponseAnalyzer على نص مخصص
+# =====================================================
+@app.post("/debug/analyze-response")
+async def debug_analyze_response(request: Request):
+    """تحليل نص مخصص بواسطة ResponseAnalyzer"""
+    verify_api_key(request)
+    body = await request.json()
+    response_text = body.get("response", "")
+    tools = body.get("tools", [])
+
+    if not response_text:
+        raise HTTPException(status_code=400, detail="response field is required")
+
+    analysis = ResponseAnalyzer.analyze(response_text, tools)
+
+    # محاكاة قرار المحرك
+    test_session = f"analyze_{uuid.uuid4().hex[:8]}"
+    enforcement = ExecutionEnforcer.post_process_response(
+        response_text, test_session, tools, analysis["tool_calls_found"]
+    )
+
+    # تنظيف
+    with CONTEXT_STORE._lock:
+        if test_session in CONTEXT_STORE._store:
+            del CONTEXT_STORE._store[test_session]
+
+    return {
+        "input_response_preview": response_text[:300],
+        "analysis": {
+            "has_actual_tool_call": analysis["has_actual_tool_call"],
+            "has_description_without_execution": (
+                analysis["has_description_without_execution"]
+            ),
+            "needs_execution_push": analysis["needs_execution_push"],
+            "described_actions_found": analysis["described_actions"],
+            "intended_tool_name": analysis.get("intended_tool_name"),
+            "tool_calls_extracted": len(analysis["tool_calls_found"]),
+            "tool_calls_details": analysis["tool_calls_found"],
+        },
+        "enforcer_decision": {
+            "needs_retry": enforcement["needs_retry"],
+            "retry_message": enforcement["retry_message"],
+        },
+        "verdict": (
+            "✅ EXECUTOR: Model actually called a tool"
+            if analysis["has_actual_tool_call"]
+            else (
+                "⚠️ DESCRIBER: Model described without executing"
+                if analysis["has_description_without_execution"]
+                else "ℹ️ NEUTRAL: Regular text response (no tools involved)"
+            )
+        )
+    }
+
+# =====================================================
+# نقطة: مراقبة الكاش
+# =====================================================
+@app.get("/debug/cache-stats")
+async def debug_cache_stats(request: Request):
+    """إحصائيات الكاش"""
+    verify_api_key(request)
+    with CACHE._lock:
+        cache_size = len(CACHE.cache)
+        now = time.time()
+        expired_count = sum(
+            1 for _, ts in CACHE.cache.values()
+            if now - ts > CACHE.ttl
+        )
+        entries = []
+        for key, (value, ts) in list(CACHE.cache.items())[:10]:
+            entries.append({
+                "key_preview": key[:50],
+                "value_length": len(value),
+                "age_seconds": round(now - ts),
+                "expired": now - ts > CACHE.ttl
+            })
+
+    return {
+        "cache_size": cache_size,
+        "max_size": CACHE.max_size,
+        "ttl_seconds": CACHE.ttl,
+        "expired_entries": expired_count,
+        "active_entries": cache_size - expired_count,
+        "sample_entries": entries,
+        "timestamp": int(time.time())
+    }
+
+# =====================================================
+# نقطة: تصدير سياق جلسة كاملة
+# =====================================================
+@app.get("/context/{session_id}/export")
+async def export_session_context(session_id: str, request: Request):
+    """تصدير سياق الجلسة كاملاً بصيغة JSON"""
+    verify_api_key(request)
+
+    ctx = CONTEXT_STORE.get_or_create_session(session_id)
+    summary = CONTEXT_STORE.get_context_summary(session_id)
+    directive = CONTEXT_STORE.get_execution_directive(session_id)
+
+    export_data = {
+        "session_id": session_id,
+        "exported_at": int(time.time()),
+        "context": {
+            "original_task": ctx.get("original_task", ""),
+            "current_state": ctx.get("current_state", ExecutionState.IDLE),
+            "message_count": ctx.get("message_count", 0),
+            "completed_steps": ctx.get("completed_steps", []),
+            "tool_results": ctx.get("tool_results", []),
+            "pending_tool_calls": ctx.get("pending_tool_calls", []),
+            "executed_tool_calls": ctx.get("executed_tool_calls", []),
+            "described_but_not_executed": ctx.get("described_but_not_executed", []),
+            "consecutive_description_count": ctx.get(
+                "consecutive_description_count", 0
+            ),
+            "next_required_action": ctx.get("next_required_action", ""),
+            "provider_history": ctx.get("provider_history", [])[-5:],
+            "created_at": ctx.get("created_at", 0),
+            "last_updated": ctx.get("last_updated", 0),
+        },
+        "human_readable_summary": summary,
+        "current_execution_directive": directive,
+    }
+
+    return export_data
+
+# =====================================================
+# نقطة: استيراد سياق جلسة
+# =====================================================
+@app.post("/context/{session_id}/import")
+async def import_session_context(session_id: str, request: Request):
+    """استيراد سياق جلسة من بيانات JSON"""
+    verify_api_key(request)
+    body = await request.json()
+    context_data = body.get("context", {})
+
+    if not context_data:
+        raise HTTPException(status_code=400, detail="context field is required")
+
+    # التحقق من الحقول المطلوبة وتعيين القيم الافتراضية
+    safe_context = {
+        "original_task": context_data.get("original_task", ""),
+        "task_breakdown": context_data.get("task_breakdown", []),
+        "completed_steps": context_data.get("completed_steps", []),
+        "tool_results": context_data.get("tool_results", []),
+        "pending_tool_calls": context_data.get("pending_tool_calls", []),
+        "executed_tool_calls": context_data.get("executed_tool_calls", []),
+        "current_state": context_data.get("current_state", ExecutionState.IDLE),
+        "next_required_action": context_data.get("next_required_action", ""),
+        "created_at": context_data.get("created_at", time.time()),
+        "last_updated": time.time(),
+        "message_count": context_data.get("message_count", 0),
+        "provider_history": context_data.get("provider_history", []),
+        "last_model_response": context_data.get("last_model_response", ""),
+        "described_but_not_executed": context_data.get("described_but_not_executed", []),
+        "consecutive_description_count": context_data.get(
+            "consecutive_description_count", 0
+        ),
+    }
+
+    with CONTEXT_STORE._lock:
+        CONTEXT_STORE._store[session_id] = safe_context
+
+    return {
+        "message": f"Context imported for session {session_id}",
+        "session_id": session_id,
+        "state": safe_context["current_state"],
+        "directive": CONTEXT_STORE.get_execution_directive(session_id)
+    }
+
+# =====================================================
+# نقطة: اختبار pattern matching للأنماط المحظورة
+# =====================================================
+@app.post("/debug/test-patterns")
+async def debug_test_patterns(request: Request):
+    """اختبار أنماط كشف الوصف بدون تنفيذ"""
+    verify_api_key(request)
+    body = await request.json()
+    test_texts = body.get("texts", [
+        "سأقوم بإنشاء الملف الآن",
+        "I will create the file",
+        "Let me write the code",
+        "I'm going to use write_file",
+        "Here is the result: 42",
+        "سأستخدم أداة write_file",
+        "Now I'll create the Python file",
+        "The file has been created successfully",
+        "I'll use the write_file tool to save your code",
+        "Using the write_file tool to create the file",
+    ])
+
+    results = []
+    for text in test_texts:
+        matched_patterns = []
+        for pattern in ResponseAnalyzer.DESCRIPTION_PHRASES:
+            matches = re.findall(pattern, text, re.IGNORECASE)
+            if matches:
+                matched_patterns.append({
+                    "pattern": pattern,
+                    "matches": matches
+                })
+
+        is_description = len(matched_patterns) > 0
+        results.append({
+            "text": text,
+            "is_description_without_execution": is_description,
+            "matched_patterns_count": len(matched_patterns),
+            "matched_patterns": matched_patterns[:3],  # أول 3 فقط
+            "verdict": (
+                "⚠️ DESCRIPTION (needs enforcement)"
+                if is_description
+                else "✅ OK (not a description pattern)"
+            )
+        })
+
+    description_count = sum(1 for r in results if r["is_description_without_execution"])
+    return {
+        "test_results": results,
+        "summary": {
+            "total_texts": len(results),
+            "description_patterns_found": description_count,
+            "clean_texts": len(results) - description_count,
+            "total_patterns_available": len(ResponseAnalyzer.DESCRIPTION_PHRASES),
+        }
+    }
+
+# =====================================================
+# نقطة: إحصائيات المزودين مع الأداء
+# =====================================================
+@app.get("/providers/stats")
+async def get_provider_stats(request: Request):
+    """إحصائيات المزودين مع معلومات الأداء من التاريخ"""
+    verify_api_key(request)
+
+    provider_usage = {}
+    for pname in REAL_PROVIDERS.keys():
+        provider_usage[pname] = {
+            "total_uses": 0,
+            "recent_uses": 0,
+            "models_used": set(),
+        }
+
+    # تحليل تاريخ الاستخدام من الجلسات
+    with CONTEXT_STORE._lock:
+        for sid, ctx in CONTEXT_STORE._store.items():
+            for ph in ctx.get("provider_history", []):
+                pname = ph.get("provider", "")
+                model = ph.get("model", "")
+                ts = ph.get("timestamp", 0)
+
+                if pname in provider_usage:
+                    provider_usage[pname]["total_uses"] += 1
+                    if model:
+                        provider_usage[pname]["models_used"].add(model)
+                    # استخدام خلال آخر ساعة
+                    if time.time() - ts < 3600:
+                        provider_usage[pname]["recent_uses"] += 1
+
+    # تحويل sets إلى lists للـ JSON
+    result = {}
+    for pname, stats in provider_usage.items():
+        pobj = REAL_PROVIDERS.get(pname)
+        available_models = discover_provider_models(pobj, pname) if pobj else []
+        result[pname] = {
+            "available": True,
+            "total_uses": stats["total_uses"],
+            "recent_uses_last_hour": stats["recent_uses"],
+            "models_actually_used": list(stats["models_used"]),
+            "all_available_models": available_models,
+        }
+
+    return {
+        "providers": result,
+        "timestamp": int(time.time())
+    }
+
+# =====================================================
+# نقطة: اختبار stream buffer مع أداة كاملة
+# =====================================================
+@app.post("/debug/test-stream-with-tool")
+async def debug_test_stream_with_tool(request: Request):
+    """اختبار stream buffer مع أداة كاملة مقسّمة على chunks"""
+    verify_api_key(request)
+    body = await request.json()
+    chunk_size = body.get("chunk_size", 5)
+
+    test_tools = [{
+        "name": "write_file",
+        "description": "Write content to a file",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string"},
+                "content": {"type": "string"}
+            },
+            "required": ["path", "content"]
+        }
+    }]
+
+    # نص يحتوي على tool call كاملة
+    test_text = (
+        'I will create the file for you.\n'
+        '<tool_call>\n'
+        '{\n'
+        '  "name": "write_file",\n'
+        '  "arguments": {\n'
+        '    "path": "hello.py",\n'
+        '    "content": "print(\'Hello World\')"\n'
+        '  }\n'
+        '}\n'
+        '</tool_call>\n'
+        'The file has been created.'
+    )
+
+    buffer = StreamToolBuffer(available_tools=test_tools)
+    all_events = []
+    text_events = []
+    tool_events = []
+
+    # محاكاة الـ streaming chunk by chunk
+    for i in range(0, len(test_text), chunk_size):
+        chunk = test_text[i:i + chunk_size]
+        events = buffer.feed(chunk)
+        for event in events:
+            all_events.append({
+                "chunk_index": i // chunk_size,
+                "chunk_preview": chunk[:10],
+                "event_type": event.get("type", "tool_use"),
+                "event_preview": (
+                    event.get("text", "")[:30]
+                    if event.get("type") == "text"
+                    else f"tool: {event.get('name', '')}"
+                )
+            })
+            if event.get("type") == "text":
+                text_events.append(event["text"])
+            else:
+                tool_events.append(event)
+
+    # تفريغ ما تبقى
+    remaining = buffer.flush()
+    for event in remaining:
+        all_events.append({
+            "chunk_index": "flush",
+            "event_type": event.get("type", "tool_use"),
+            "event_preview": (
+                event.get("text", "")[:30]
+                if event.get("type") == "text"
+                else f"tool: {event.get('name', '')}"
+            )
+        })
+        if event.get("type") == "text":
+            text_events.append(event["text"])
+        else:
+            tool_events.append(event)
+
+    return {
+        "input_text_length": len(test_text),
+        "chunk_size": chunk_size,
+        "total_chunks": (len(test_text) + chunk_size - 1) // chunk_size,
+        "total_events": len(all_events),
+        "text_events_count": len(text_events),
+        "tool_events_count": len(tool_events),
+        "reconstructed_text": "".join(text_events),
+        "tool_calls_detected": tool_events,
+        "success": len(tool_events) > 0,
+        "verdict": (
+            "✅ Stream buffer correctly detected tool call"
+            if len(tool_events) > 0
+            else "❌ Stream buffer missed the tool call"
+        ),
+        "all_events_sample": all_events[:20]
+    }
+
+# =====================================================
+# MAIN ENTRY POINT
+# =====================================================
+if __name__ == "__main__":
+    import uvicorn
+
+    port = int(os.getenv("PORT", 8000))
+    host = os.getenv("HOST", "0.0.0.0")
+    workers = int(os.getenv("WORKERS", 1))
+    log_level = os.getenv("LOG_LEVEL", "info").lower()
+
+    logger.info(f"Starting G4F Execution Engine v6.0.0")
+    logger.info(f"Host: {host}, Port: {port}")
+    logger.info(f"Workers: {workers}")
+    logger.info(f"Cookie Status: {COOKIE_STATUS}")
+    logger.info(f"Providers: {list(REAL_PROVIDERS.keys())}")
+
+    uvicorn.run(
+        "main:app",
+        host=host,
+        port=port,
+        workers=workers,
+        log_level=log_level,
+        reload=False,
+        access_log=True,
     )