Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,58 @@
+# Git files
+.git
+.gitignore
+.gitattributes
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Workspace and temp files
+workspace/
+tmp/
+temp/
+*.tmp
+
+# Logs
+*.log
+logs/
+
+# Backup files
+*_backup.*
+*.bak
+
+# Large files that aren't needed
+assets/
+examples/
+tests/
+.pytest_cache/
+
+# Documentation (keep only README.md)
+*.md
+!README.md
+
+# Config examples
+config/config.example*.toml
+
+# Deployment docs
+DEPLOYMENT_*.md
+docker-commands.md

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

DEPLOYMENT_INFO.md

@@ -0,0 +1,63 @@
+# OpenManus HuggingFace Deployment Package
+
+## 📦 Package Contents
+- **Total Files**: 35
+- **Missing Files**: 0
+
+## ✅ Included Files
+- Dockerfile
+- README.md
+- app/__init__.py
+- app/agent/__init__.py
+- app/agent/base.py
+- app/agent/manus.py
+- app/agent/toolcall.py
+- app/auth.py
+- app/auth_interface.py
+- app/auth_service.py
+- app/cloudflare/__init__.py
+- app/cloudflare/client.py
+- app/cloudflare/d1.py
+- app/cloudflare/durable_objects.py
+- app/cloudflare/kv.py
+- app/cloudflare/r2.py
+- app/config.py
+- app/huggingface_models.py
+- app/logger.py
+- app/production_config.py
+- app/prompt/__init__.py
+- app/prompt/manus.py
+- app/schema.py
+- app/tool/__init__.py
+- app/tool/ask_human.py
+- app/tool/base.py
+- app/tool/python_execute.py
+- app/tool/str_replace_editor.py
+- app/tool/terminate.py
+- app/tool/tool_collection.py
+- app/utils/__init__.py
+- app/utils/logger.py
+- app_production.py
+- requirements.txt
+- schema.sql
+
+
+## 🚀 Deployment Instructions
+
+1. **Upload all files** from this package to your HuggingFace Space
+2. **Set environment variables** in Space settings:
+   - `ENVIRONMENT=production`
+   - `HF_TOKEN=your_token` (optional)
+   - `CLOUDFLARE_API_TOKEN=your_token` (optional)
+
+3. **Monitor build logs** during deployment
+4. **Test authentication** after successful deployment
+
+## 🎯 What This Includes
+- ✅ Complete authentication system (mobile + password)
+- ✅ 200+ AI model configurations
+- ✅ Cloudflare services integration
+- ✅ Production-ready Docker setup
+- ✅ Comprehensive error handling
+
+Ready for HuggingFace Spaces! 🚀

DEPLOYMENT_SUCCESS.md

@@ -0,0 +1,248 @@
+# 🎉 Deployment Successful - ORYNXML Complete AI Platform
+
+## ✅ What Was Fixed
+
+### Problem
+- **Error**: `RuntimeError: Directory 'static' does not exist`
+- **Root Cause**: Space was trying to run FastAPI (`main.py`) instead of Gradio (`app.py`)
+- **Reason**: README.md had incorrect metadata configuration
+
+### Solution
+✅ Updated `agnt/README.md` with correct Gradio configuration:
+```yaml
+---
+title: ORYNXML Complete AI Platform
+emoji: 🤖
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+sdk_version: 4.44.1
+app_file: app.py
+pinned: false
+---
+```
+
+✅ Redeployed README.md to Hugging Face Space
+✅ Space now correctly recognizes as **Gradio SDK**
+
+---
+
+## 🚀 Your Backend is Ready!
+
+### 🔗 Space URL
+**https://huggingface.co/spaces/Speedofmastery/yyuu-complete-ai**
+
+### 📊 Current Status
+- ✅ **SDK**: Gradio (correct!)
+- ⏸️ **State**: PAUSED (needs restart)
+- 💻 **Hardware**: NVIDIA A10G GPU configured
+- 📦 **Models**: 211 models across 8 categories
+
+---
+
+## 🎯 Next Steps to Complete Deployment
+
+### 1️⃣ **RESTART THE SPACE** (Manual Action Required)
+You need to manually restart the Space:
+
+1. Go to: https://huggingface.co/spaces/Speedofmastery/yyuu-complete-ai/settings
+2. Click **"Factory Rebuild"** button
+3. Wait for build to complete (~2-3 minutes)
+4. Space will automatically start and load the Gradio interface
+
+### 2️⃣ **Verify Space is Running**
+After rebuild:
+- Visit: https://huggingface.co/spaces/Speedofmastery/yyuu-complete-ai
+- You should see the Gradio interface with 11 tabs:
+  - Sign Up
+  - Login
+  - Text Generation
+  - Image Processing
+  - Image Editing
+  - Video Generation
+  - AI Teacher & Education
+  - Software Engineer Agent
+  - Audio Processing
+  - Multimodal & Avatars
+  - Arabic-English
+
+### 3️⃣ **Test Authentication**
+- Create a test account using the Sign Up tab
+- Try logging in with the credentials
+- SQLite database (`openmanus.db`) will be created automatically
+
+### 4️⃣ **Test AI Models**
+- Select any model from the dropdowns
+- Enter a prompt
+- Verify the simulated response is displayed
+
+---
+
+## 📦 What's Deployed
+
+### Backend (`app.py` - 1014 lines)
+✅ **8 Complete Agent Categories with 211 Models:**
+
+1. **Text Generation** (52 models)
+   - Qwen Models (35): Qwen2.5-72B, QwQ-32B, Coder series, Math series
+   - DeepSeek Models (17): DeepSeek-R1, V2-Chat, Coder series
+
+2. **Image Processing** (31 models)
+   - Generation (10): FLUX.1, Stable Diffusion, Kandinsky, Midjourney
+   - Editing (15): Pix2Pix, ControlNet, PhotoMaker, InstantID
+   - Face Processing (6): InsightFace, GFPGAN, CodeFormer, Real-ESRGAN
+
+3. **Image Editing** (15 models)
+   - Specialized editing: Inpainting, ControlNet, Style transfer
+
+4. **Video Generation** (18 models)
+   - Text-to-Video (8): Ali-ViLab, ModelScope, AnimateDiff
+   - Image-to-Video (5): Stable Video Diffusion, ToonCrafter
+   - Video Editing (5): Tune-A-Video, Text2Video-Zero
+
+5. **AI Teacher & Education** (21 models)
+   - Math & Science (6): Qwen2.5-Math, WizardMath
+   - Coding Tutor (5): Qwen Coder, DeepSeek Coder
+   - Language Learning (5): NLLB-200, SeamlessM4T
+   - General Education (5): Mistral, Phi-3, Nous-Hermes
+
+6. **Software Engineer Agent** (27 models)
+   - Code Generation (10): CodeLlama 70B/34B/13B/7B, Qwen Coder
+   - Code Review (7): StarCoder2, WizardCoder, Phind-CodeLlama
+   - Specialized Coding (6): CodeGen, Replit, PolyCoder
+   - DevOps (4): Infrastructure & deployment models
+
+7. **Audio Processing** (30 models)
+   - Text-to-Speech (15): SpeechT5, MMS-TTS, XTTS-v2, Bark
+   - Speech-to-Text (15): Whisper (all sizes), Wav2Vec2, MMS
+
+8. **Multimodal AI** (20 models)
+   - Vision-Language (11): LLaVA, BLIP2, Git, ViLT
+   - Talking Avatars (9): Wav2Lip, DeepFaceLive, FaceRig
+
+9. **Arabic-English** (12 models)
+   - BERT models, AraBERT, MARBERT, NLLB translation
+
+### Frontend (9 HTML Pages)
+✅ All pages use **ORYNXML branding**:
+- Colors: Blue (#1B5DA8, #4DA3FF), Dark (#0A1628)
+- Logo: Hexagonal design from ibb.co
+
+**Current Pages:**
+1. `index.html` - Landing page
+2. `signup.html` - User registration
+3. `login.html` - Authentication
+4. `dashboard.html` - Main hub
+5. `chat.html` - AI chat interface (updated with 8 categories)
+6. `terminal.html` - Command terminal
+7. `browser.html` - Web browser
+8. `files.html` - File manager
+9. `visualize.html` - Data visualization
+
+---
+
+## 🔮 Future Enhancements (Optional)
+
+### A. Create 7 Specialized Visual Interfaces
+Replace simulated responses with rich UI:
+
+1. **`image-gen.html`** - Image generation studio
+   - Model selector, prompt builder, image gallery
+   - Real-time generation from FLUX.1/SDXL
+
+2. **`code-review.html`** - Code review dashboard
+   - Code editor, diff viewer, suggestions panel
+   - Integration with Software Engineer Agent
+
+3. **`audio-studio.html`** - Audio processing workspace
+   - TTS voice selector, STT transcription
+   - Audio player and waveform visualization
+
+4. **`ai-teacher.html`** - Interactive learning platform
+   - Subject selector, problem solver, step-by-step explanations
+   - Math equation renderer, code examples
+
+5. **`vision-lab.html`** - Computer vision workspace
+   - Image upload, VQA interface, captioning
+   - Multi-image comparison
+
+6. **`video-gen.html`** - Video generation studio
+   - Text-to-video/image-to-video interface
+   - Timeline editor, preview player
+
+7. **`image-edit.html`** - Advanced image editor
+   - ControlNet, inpainting, style transfer
+   - Before/after comparison
+
+### B. Connect Frontend to Backend API
+- Create API endpoints in `app.py` for each category
+- Replace simulated responses with real model inference
+- Add authentication middleware
+- Implement rate limiting and usage tracking
+
+### C. Enhanced Features
+- User dashboard with usage statistics
+- Model comparison side-by-side
+- Save/load conversation history
+- Export results (images, audio, code)
+- API key management for external services
+
+---
+
+## 📊 Technical Stack Summary
+
+### Backend
+- **Framework**: Gradio 4.44.1
+- **Database**: SQLite (openmanus.db)
+- **Authentication**: Mobile number + SHA-256 password hashing
+- **AI Models**: 211 models from HuggingFace Hub
+- **Deployment**: Hugging Face Spaces (NVIDIA A10G GPU)
+
+### Frontend
+- **Framework**: Pure HTML/CSS/JavaScript
+- **Styling**: ORYNXML blue gradient theme
+- **Icons**: Lucide Icons
+- **Hosting**: Ready for Cloudflare Pages
+- **Backend Integration**: API calls to HF Space
+
+### Infrastructure
+- **Cloudflare Services**: D1, R2, KV, Durable Objects (configured)
+- **GPU**: NVIDIA A10G (Space hardware)
+- **Storage**: SQLite database persists in Space
+
+---
+
+## 🎉 Deployment Checklist
+
+- ✅ Backend code complete (app.py - 1014 lines)
+- ✅ Requirements.txt with all dependencies
+- ✅ README.md with correct Gradio configuration
+- ✅ Uploaded to HuggingFace Space
+- ✅ README.md redeployed with fix
+- ✅ Space recognized as Gradio SDK
+- ⏸️ **PENDING**: Space restart (manual action required)
+- ⏸️ **PENDING**: Test authentication and models
+- ⏸️ **PENDING**: Create 7 specialized frontend pages (optional)
+- ⏸️ **PENDING**: Connect frontend to backend API
+
+---
+
+## 🔗 Important Links
+
+- **Space URL**: https://huggingface.co/spaces/Speedofmastery/yyuu-complete-ai
+- **Settings**: https://huggingface.co/spaces/Speedofmastery/yyuu-complete-ai/settings
+- **Logs**: https://huggingface.co/spaces/Speedofmastery/yyuu-complete-ai/logs
+- **Files**: https://huggingface.co/spaces/Speedofmastery/yyuu-complete-ai/tree/main
+
+---
+
+## 🚨 Action Required
+
+**Go to Space Settings and click "Factory Rebuild" to complete deployment!**
+
+After rebuild, your complete AI platform with 211 models will be live at:
+**https://huggingface.co/spaces/Speedofmastery/yyuu-complete-ai**
+
+---
+
+*Last updated: Configuration fix deployed, awaiting manual Space restart*

Dockerfile

@@ -0,0 +1,31 @@
+# Simple production Docker with Python 3.10
+FROM python:3.10
+
+# Environment variables
+ENV PYTHONUNBUFFERED=1 \
+    GRADIO_SERVER_NAME=0.0.0.0 \
+    GRADIO_SERVER_PORT=7860
+
+# Create user
+RUN useradd -m -u 1000 user
+USER user
+
+# Set paths
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+# Copy and install requirements
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy app
+COPY --chown=user app.py .
+
+# Expose port
+EXPOSE 7860
+
+# Run app
+CMD ["python", "app.py"]

README.md

@@ -1,12 +1,247 @@
----
-title: or
-emoji: 🐳
-colorFrom: pink
-colorTo: pink
-sdk: static
-pinned: false
-tags:
-  - deepsite
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: ORYNXML Complete AI Platform
+emoji: 🤖
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+app_port: 7860
+pinned: true
+license: apache-2.0
+short_description: Complete AI Platform with 211 models across 8 categories
+tags:
+- AI
+- Authentication
+- Multi-Modal
+- HuggingFace
+- OpenManus
+- Qwen
+- DeepSeek
+- TTS
+- STT
+- Face-Swap
+- Avatar
+- Arabic
+- English
+- Cloudflare
+---
+
+<p align="center">
+  <img src="assets/logo.jpg" width="200"/>
+</p>
+
+English | [中文](README_zh.md) | [한국어](README_ko.md) | [日本語](README_ja.md)
+
+[![GitHub stars](https://img.shields.io/github/stars/FoundationAgents/OpenManus?style=social)](https://github.com/FoundationAgents/OpenManus/stargazers)
+&ensp;
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) &ensp;
+[![Discord Follow](https://dcbadge.vercel.app/api/server/DYn29wFk9z?style=flat)](https://discord.gg/DYn29wFk9z)
+[![Demo](https://img.shields.io/badge/Demo-Hugging%20Face-yellow)](https://huggingface.co/spaces/lyh-917/OpenManusDemo)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.15186407.svg)](https://doi.org/10.5281/zenodo.15186407)
+
+# 👋 OpenManus - Complete AI Platform
+
+🤖 **200+ AI Models + Mobile Authentication + Cloudflare Services**
+
+Manus is incredible, but OpenManus can achieve any idea without an *Invite Code* 🛫!
+
+## 🌟 Environment Variables
+
+Set these in your HuggingFace Space settings for full functionality:
+
+```bash
+# Required for full Cloudflare integration
+CLOUDFLARE_API_TOKEN=your_cloudflare_token
+CLOUDFLARE_ACCOUNT_ID=your_account_id
+CLOUDFLARE_D1_DATABASE_ID=your_d1_database_id
+CLOUDFLARE_R2_BUCKET_NAME=your_r2_bucket
+CLOUDFLARE_KV_NAMESPACE_ID=your_kv_namespace
+
+# Enhanced AI model access
+HF_TOKEN=your_huggingface_token
+OPENAI_API_KEY=your_openai_key
+ANTHROPIC_API_KEY=your_anthropic_key
+
+# Application configuration
+ENVIRONMENT=production
+LOG_LEVEL=INFO
+SECRET_KEY=your_secret_key
+```
+
+Our team members [@Xinbin Liang](https://github.com/mannaandpoem) and [@Jinyu Xiang](https://github.com/XiangJinyu) (core authors), along with [@Zhaoyang Yu](https://github.com/MoshiQAQ), [@Jiayi Zhang](https://github.com/didiforgithub), and [@Sirui Hong](https://github.com/stellaHSR), we are from [@MetaGPT](https://github.com/geekan/MetaGPT). The prototype is launched within 3 hours and we are keeping building!
+
+It's a simple implementation, so we welcome any suggestions, contributions, and feedback!
+
+Enjoy your own agent with OpenManus!
+
+We're also excited to introduce [OpenManus-RL](https://github.com/OpenManus/OpenManus-RL), an open-source project dedicated to reinforcement learning (RL)- based (such as GRPO) tuning methods for LLM agents, developed collaboratively by researchers from UIUC and OpenManus.
+
+## Project Demo
+
+<video src="https://private-user-images.githubusercontent.com/61239030/420168772-6dcfd0d2-9142-45d9-b74e-d10aa75073c6.mp4?jwt=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJnaXRodWIuY29tIiwiYXVkIjoicmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbSIsImtleSI6ImtleTUiLCJleHAiOjE3NDEzMTgwNTksIm5iZiI6MTc0MTMxNzc1OSwicGF0aCI6Ii82MTIzOTAzMC80MjAxNjg3NzItNmRjZmQwZDItOTE0Mi00NWQ5LWI3NGUtZDEwYWE3NTA3M2M2Lm1wND9YLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1DcmVkZW50aWFsPUFLSUFWQ09EWUxTQTUzUFFLNFpBJTJGMjAyNTAzMDclMkZ1cy1lYXN0LTElMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1EYXRlPTIwMjUwMzA3VDAzMjIzOVomWC1BbXotRXhwaXJlcz0zMDAmWC1BbXotU2lnbmF0dXJlPTdiZjFkNjlmYWNjMmEzOTliM2Y3M2VlYjgyNDRlZDJmOWE3NWZhZjE1MzhiZWY4YmQ3NjdkNTYwYTU5ZDA2MzYmWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0In0.UuHQCgWYkh0OQq9qsUWqGsUbhG3i9jcZDAMeHjLt5T4" data-canonical-src="https://private-user-images.githubusercontent.com/61239030/420168772-6dcfd0d2-9142-45d9-b74e-d10aa75073c6.mp4?jwt=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJnaXRodWIuY29tIiwiYXVkIjoicmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbSIsImtleSI6ImtleTUiLCJleHAiOjE3NDEzMTgwNTksIm5iZiI6MTc0MTMxNzc1OSwicGF0aCI6Ii82MTIzOTAzMC80MjAxNjg3NzItNmRjZmQwZDItOTE0Mi00NWQ5LWI3NGUtZDEwYWE3NTA3M2M2Lm1wND9YLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1DcmVkZW50aWFsPUFLSUFWQ09EWUxTQTUzUFFLNFpBJTJGMjAyNTAzMDclMkZ1cy1lYXN0LTElMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1EYXRlPTIwMjUwMzA3VDAzMjIzOVomWC1BbXotRXhwaXJlcz0zMDAmWC1BbXotU2lnbmF0dXJlPTdiZjFkNjlmYWNjMmEzOTliM2Y3M2VlYjgyNDRlZDJmOWE3NWZhZjE1MzhiZWY4YmQ3NjdkNTYwYTU5ZDA2MzYmWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0In0.UuHQCgWYkh0OQq9qsUWqGsUbhG3i9jcZDAMeHjLt5T4" controls="controls" muted="muted" class="d-block rounded-bottom-2 border-top width-fit" style="max-height:640px; min-height: 200px"></video>
+
+## Installation
+
+We provide two installation methods. Method 2 (using uv) is recommended for faster installation and better dependency management.
+
+### Method 1: Using conda
+
+1. Create a new conda environment:
+
+```bash
+conda create -n open_manus python=3.12
+conda activate open_manus
+```
+
+2. Clone the repository:
+
+```bash
+git clone https://github.com/FoundationAgents/OpenManus.git
+cd OpenManus
+```
+
+3. Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+### Method 2: Using uv (Recommended)
+
+1. Install uv (A fast Python package installer and resolver):
+
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+2. Clone the repository:
+
+```bash
+git clone https://github.com/FoundationAgents/OpenManus.git
+cd OpenManus
+```
+
+3. Create a new virtual environment and activate it:
+
+```bash
+uv venv --python 3.12
+source .venv/bin/activate  # On Unix/macOS
+# Or on Windows:
+# .venv\Scripts\activate
+```
+
+4. Install dependencies:
+
+```bash
+uv pip install -r requirements.txt
+```
+
+### Browser Automation Tool (Optional)
+```bash
+playwright install
+```
+
+## Configuration
+
+OpenManus requires configuration for the LLM APIs it uses. Follow these steps to set up your configuration:
+
+1. Create a `config.toml` file in the `config` directory (you can copy from the example):
+
+```bash
+cp config/config.example.toml config/config.toml
+```
+
+2. Edit `config/config.toml` to add your API keys and customize settings:
+
+```toml
+# Global LLM configuration
+[llm]
+model = "gpt-4o"
+base_url = "https://api.openai.com/v1"
+api_key = "sk-..."  # Replace with your actual API key
+max_tokens = 4096
+temperature = 0.0
+
+# Optional configuration for specific LLM models
+[llm.vision]
+model = "gpt-4o"
+base_url = "https://api.openai.com/v1"
+api_key = "sk-..."  # Replace with your actual API key
+```
+
+## Quick Start
+
+One line for run OpenManus:
+
+```bash
+python main.py
+```
+
+Then input your idea via terminal!
+
+For MCP tool version, you can run:
+```bash
+python run_mcp.py
+```
+
+For unstable multi-agent version, you also can run:
+
+```bash
+python run_flow.py
+```
+
+### Custom Adding Multiple Agents
+
+Currently, besides the general OpenManus Agent, we have also integrated the DataAnalysis Agent, which is suitable for data analysis and data visualization tasks. You can add this agent to `run_flow` in `config.toml`.
+
+```toml
+# Optional configuration for run-flow
+[runflow]
+use_data_analysis_agent = true     # Disabled by default, change to true to activate
+```
+In addition, you need to install the relevant dependencies to ensure the agent runs properly: [Detailed Installation Guide](app/tool/chart_visualization/README.md##Installation)
+
+## How to contribute
+
+We welcome any friendly suggestions and helpful contributions! Just create issues or submit pull requests.
+
+Or contact @mannaandpoem via 📧email: mannaandpoem@gmail.com
+
+**Note**: Before submitting a pull request, please use the pre-commit tool to check your changes. Run `pre-commit run --all-files` to execute the checks.
+
+## Community Group
+Join our networking group on Feishu and share your experience with other developers!
+
+<div align="center" style="display: flex; gap: 20px;">
+    <img src="assets/community_group.jpg" alt="OpenManus 交流群" width="300" />
+</div>
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=FoundationAgents/OpenManus&type=Date)](https://star-history.com/#FoundationAgents/OpenManus&Date)
+
+## Sponsors
+Thanks to [PPIO](https://ppinfra.com/user/register?invited_by=OCPKCN&utm_source=github_openmanus&utm_medium=github_readme&utm_campaign=link) for computing source support.
+> PPIO: The most affordable and easily-integrated MaaS and GPU cloud solution.
+
+
+## Acknowledgement
+
+Thanks to [anthropic-computer-use](https://github.com/anthropics/anthropic-quickstarts/tree/main/computer-use-demo), [browser-use](https://github.com/browser-use/browser-use) and [crawl4ai](https://github.com/unclecode/crawl4ai) for providing basic support for this project!
+
+Additionally, we are grateful to [AAAJ](https://github.com/metauto-ai/agent-as-a-judge), [MetaGPT](https://github.com/geekan/MetaGPT), [OpenHands](https://github.com/All-Hands-AI/OpenHands) and [SWE-agent](https://github.com/SWE-agent/SWE-agent).
+
+We also thank stepfun(阶跃星辰) for supporting our Hugging Face demo space.
+
+OpenManus is built by contributors from MetaGPT. Huge thanks to this agent community!
+
+## Cite
+```bibtex
+@misc{openmanus2025,
+  author = {Xinbin Liang and Jinyu Xiang and Zhaoyang Yu and Jiayi Zhang and Sirui Hong and Sheng Fan and Xiao Tang},
+  title = {OpenManus: An open-source framework for building general AI agents},
+  year = {2025},
+  publisher = {Zenodo},
+  doi = {10.5281/zenodo.15186407},
+  url = {https://doi.org/10.5281/zenodo.15186407},
+}
+```

app.py

@@ -0,0 +1,1013 @@
+import gradio as gr
+import os
+import json
+import sqlite3
+import hashlib
+import datetime
+from pathlib import Path
+
+# Cloudflare configuration
+CLOUDFLARE_CONFIG = {
+    "api_token": os.getenv("CLOUDFLARE_API_TOKEN", ""),
+    "account_id": os.getenv("CLOUDFLARE_ACCOUNT_ID", ""),
+    "d1_database_id": os.getenv("CLOUDFLARE_D1_DATABASE_ID", ""),
+    "r2_bucket_name": os.getenv("CLOUDFLARE_R2_BUCKET_NAME", ""),
+    "kv_namespace_id": os.getenv("CLOUDFLARE_KV_NAMESPACE_ID", ""),
+    "durable_objects_id": os.getenv("CLOUDFLARE_DURABLE_OBJECTS_ID", ""),
+}
+
+# AI Model Categories with 200+ models
+AI_MODELS = {
+    "Text Generation": {
+        "Qwen Models": [
+            "Qwen/Qwen2.5-72B-Instruct",
+            "Qwen/Qwen2.5-32B-Instruct",
+            "Qwen/Qwen2.5-14B-Instruct",
+            "Qwen/Qwen2.5-7B-Instruct",
+            "Qwen/Qwen2.5-3B-Instruct",
+            "Qwen/Qwen2.5-1.5B-Instruct",
+            "Qwen/Qwen2.5-0.5B-Instruct",
+            "Qwen/Qwen2-72B-Instruct",
+            "Qwen/Qwen2-57B-A14B-Instruct",
+            "Qwen/Qwen2-7B-Instruct",
+            "Qwen/Qwen2-1.5B-Instruct",
+            "Qwen/Qwen2-0.5B-Instruct",
+            "Qwen/Qwen1.5-110B-Chat",
+            "Qwen/Qwen1.5-72B-Chat",
+            "Qwen/Qwen1.5-32B-Chat",
+            "Qwen/Qwen1.5-14B-Chat",
+            "Qwen/Qwen1.5-7B-Chat",
+            "Qwen/Qwen1.5-4B-Chat",
+            "Qwen/Qwen1.5-1.8B-Chat",
+            "Qwen/Qwen1.5-0.5B-Chat",
+            "Qwen/CodeQwen1.5-7B-Chat",
+            "Qwen/Qwen2.5-Math-72B-Instruct",
+            "Qwen/Qwen2.5-Math-7B-Instruct",
+            "Qwen/Qwen2.5-Coder-32B-Instruct",
+            "Qwen/Qwen2.5-Coder-14B-Instruct",
+            "Qwen/Qwen2.5-Coder-7B-Instruct",
+            "Qwen/Qwen2.5-Coder-3B-Instruct",
+            "Qwen/Qwen2.5-Coder-1.5B-Instruct",
+            "Qwen/Qwen2.5-Coder-0.5B-Instruct",
+            "Qwen/QwQ-32B-Preview",
+            "Qwen/Qwen2-VL-72B-Instruct",
+            "Qwen/Qwen2-VL-7B-Instruct",
+            "Qwen/Qwen2-VL-2B-Instruct",
+            "Qwen/Qwen2-Audio-7B-Instruct",
+            "Qwen/Qwen-Agent-Chat",
+            "Qwen/Qwen-VL-Chat",
+        ],
+        "DeepSeek Models": [
+            "deepseek-ai/deepseek-llm-67b-chat",
+            "deepseek-ai/deepseek-llm-7b-chat",
+            "deepseek-ai/deepseek-coder-33b-instruct",
+            "deepseek-ai/deepseek-coder-7b-instruct",
+            "deepseek-ai/deepseek-coder-6.7b-instruct",
+            "deepseek-ai/deepseek-coder-1.3b-instruct",
+            "deepseek-ai/DeepSeek-V2-Chat",
+            "deepseek-ai/DeepSeek-V2-Lite-Chat",
+            "deepseek-ai/deepseek-math-7b-instruct",
+            "deepseek-ai/deepseek-moe-16b-chat",
+            "deepseek-ai/deepseek-vl-7b-chat",
+            "deepseek-ai/deepseek-vl-1.3b-chat",
+            "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
+            "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B",
+            "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
+            "deepseek-ai/DeepSeek-R1-Distill-Llama-8B",
+            "deepseek-ai/DeepSeek-Reasoner-R1",
+        ],
+    },
+    "Image Processing": {
+        "Image Generation": [
+            "black-forest-labs/FLUX.1-dev",
+            "black-forest-labs/FLUX.1-schnell",
+            "black-forest-labs/FLUX.1-pro",
+            "runwayml/stable-diffusion-v1-5",
+            "stabilityai/stable-diffusion-xl-base-1.0",
+            "stabilityai/stable-diffusion-3-medium-diffusers",
+            "stabilityai/sd-turbo",
+            "kandinsky-community/kandinsky-2-2-decoder",
+            "playgroundai/playground-v2.5-1024px-aesthetic",
+            "midjourney/midjourney-v6",
+        ],
+        "Image Editing": [
+            "timbrooks/instruct-pix2pix",
+            "runwayml/stable-diffusion-inpainting",
+            "stabilityai/stable-diffusion-xl-refiner-1.0",
+            "lllyasviel/control_v11p_sd15_inpaint",
+            "SG161222/RealVisXL_V4.0",
+            "ByteDance/SDXL-Lightning",
+            "segmind/SSD-1B",
+            "segmind/Segmind-Vega",
+            "playgroundai/playground-v2-1024px-aesthetic",
+            "stabilityai/stable-cascade",
+            "lllyasviel/ControlNet-v1-1",
+            "lllyasviel/sd-controlnet-canny",
+            "Monster-Labs/control_v1p_sd15_qrcode_monster",
+            "TencentARC/PhotoMaker",
+            "instantX/InstantID",
+        ],
+        "Face Processing": [
+            "InsightFace/inswapper_128.onnx",
+            "deepinsight/insightface",
+            "TencentARC/GFPGAN",
+            "sczhou/CodeFormer",
+            "xinntao/Real-ESRGAN",
+            "ESRGAN/ESRGAN",
+        ],
+    },
+    "Video Generation": {
+        "Text-to-Video": [
+            "ali-vilab/text-to-video-ms-1.7b",
+            "damo-vilab/text-to-video-ms-1.7b",
+            "modelscope/text-to-video-synthesis",
+            "camenduru/potat1",
+            "stabilityai/stable-video-diffusion-img2vid",
+            "stabilityai/stable-video-diffusion-img2vid-xt",
+            "ByteDance/AnimateDiff",
+            "guoyww/animatediff",
+        ],
+        "Image-to-Video": [
+            "stabilityai/stable-video-diffusion-img2vid",
+            "stabilityai/stable-video-diffusion-img2vid-xt-1-1",
+            "TencentARC/MotionCtrl",
+            "ali-vilab/i2vgen-xl",
+            "Doubiiu/ToonCrafter",
+        ],
+        "Video Editing": [
+            "MCG-NJU/VideoMAE",
+            "showlab/Tune-A-Video",
+            "Picsart-AI-Research/Text2Video-Zero",
+            "damo-vilab/MS-Vid2Vid-XL",
+            "kabachuha/sd-webui-deforum",
+        ],
+    },
+    "AI Teacher & Education": {
+        "Math & Science": [
+            "Qwen/Qwen2.5-Math-72B-Instruct",
+            "Qwen/Qwen2.5-Math-7B-Instruct",
+            "deepseek-ai/deepseek-math-7b-instruct",
+            "mistralai/Mistral-Math-7B-v0.1",
+            "WizardLM/WizardMath-70B-V1.0",
+            "MathGPT/MathGPT-32B",
+        ],
+        "Coding Tutor": [
+            "Qwen/Qwen2.5-Coder-32B-Instruct",
+            "deepseek-ai/deepseek-coder-33b-instruct",
+            "WizardLM/WizardCoder-Python-34B-V1.0",
+            "bigcode/starcoder2-15b-instruct-v0.1",
+            "meta-llama/CodeLlama-34b-Instruct-hf",
+        ],
+        "Language Learning": [
+            "facebook/nllb-200-3.3B",
+            "facebook/seamless-m4t-v2-large",
+            "Helsinki-NLP/opus-mt-multilingual",
+            "google/madlad400-10b-mt",
+            "Unbabel/TowerInstruct-7B-v0.1",
+        ],
+        "General Education": [
+            "Qwen/Qwen2.5-72B-Instruct",
+            "microsoft/Phi-3-medium-128k-instruct",
+            "mistralai/Mistral-7B-Instruct-v0.3",
+            "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO",
+            "openchat/openchat-3.5-1210",
+        ],
+    },
+    "Software Engineer Agent": {
+        "Code Generation": [
+            "Qwen/Qwen2.5-Coder-32B-Instruct",
+            "Qwen/Qwen2.5-Coder-14B-Instruct",
+            "Qwen/Qwen2.5-Coder-7B-Instruct",
+            "deepseek-ai/deepseek-coder-33b-instruct",
+            "deepseek-ai/deepseek-coder-7b-instruct",
+            "deepseek-ai/deepseek-coder-6.7b-instruct",
+            "meta-llama/CodeLlama-70b-Instruct-hf",
+            "meta-llama/CodeLlama-34b-Instruct-hf",
+            "meta-llama/CodeLlama-13b-Instruct-hf",
+            "meta-llama/CodeLlama-7b-Instruct-hf",
+        ],
+        "Code Analysis & Review": [
+            "bigcode/starcoder2-15b-instruct-v0.1",
+            "bigcode/starcoder2-7b",
+            "bigcode/starcoderbase-7b",
+            "WizardLM/WizardCoder-Python-34B-V1.0",
+            "WizardLM/WizardCoder-15B-V1.0",
+            "Phind/Phind-CodeLlama-34B-v2",
+            "codellama/CodeLlama-70b-Python-hf",
+        ],
+        "Specialized Coding": [
+            "Salesforce/codegen25-7b-multi",
+            "Salesforce/codegen-16B-multi",
+            "replit/replit-code-v1-3b",
+            "NinedayWang/PolyCoder-2.7B",
+            "stabilityai/stablelm-base-alpha-7b-v2",
+            "teknium/OpenHermes-2.5-Mistral-7B",
+        ],
+        "DevOps & Infrastructure": [
+            "deepseek-ai/deepseek-coder-33b-instruct",
+            "Qwen/Qwen2.5-Coder-32B-Instruct",
+            "mistralai/Mistral-7B-Instruct-v0.3",
+            "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO",
+        ],
+    },
+    "Audio Processing": {
+        "Text-to-Speech": [
+            "microsoft/speecht5_tts",
+            "facebook/mms-tts-eng",
+            "facebook/mms-tts-ara",
+            "coqui/XTTS-v2",
+            "suno/bark",
+            "parler-tts/parler-tts-large-v1",
+            "microsoft/DisTTS",
+            "facebook/fastspeech2-en-ljspeech",
+            "espnet/kan-bayashi_ljspeech_vits",
+            "facebook/tts_transformer-en-ljspeech",
+            "microsoft/SpeechT5",
+            "Voicemod/fastspeech2-en-male1",
+            "facebook/mms-tts-spa",
+            "facebook/mms-tts-fra",
+            "facebook/mms-tts-deu",
+        ],
+        "Speech-to-Text": [
+            "openai/whisper-large-v3",
+            "openai/whisper-large-v2",
+            "openai/whisper-medium",
+            "openai/whisper-small",
+            "openai/whisper-base",
+            "openai/whisper-tiny",
+            "facebook/wav2vec2-large-960h",
+            "facebook/wav2vec2-base-960h",
+            "microsoft/unispeech-sat-large",
+            "nvidia/stt_en_conformer_ctc_large",
+            "speechbrain/asr-wav2vec2-commonvoice-en",
+            "facebook/mms-1b-all",
+            "facebook/seamless-m4t-v2-large",
+            "distil-whisper/distil-large-v3",
+            "distil-whisper/distil-medium.en",
+        ],
+    },
+    "Multimodal AI": {
+        "Vision-Language": [
+            "microsoft/DialoGPT-large",
+            "microsoft/blip-image-captioning-large",
+            "microsoft/blip2-opt-6.7b",
+            "microsoft/blip2-flan-t5-xl",
+            "salesforce/blip-vqa-capfilt-large",
+            "dandelin/vilt-b32-finetuned-vqa",
+            "google/pix2struct-ai2d-base",
+            "microsoft/git-large-coco",
+            "microsoft/git-base-vqa",
+            "liuhaotian/llava-v1.6-34b",
+            "liuhaotian/llava-v1.6-vicuna-7b",
+        ],
+        "Talking Avatars": [
+            "microsoft/SpeechT5-TTS-Avatar",
+            "Wav2Lip-HD",
+            "First-Order-Model",
+            "LipSync-Expert",
+            "DeepFaceLive",
+            "FaceSwapper-Live",
+            "RealTime-FaceRig",
+            "AI-Avatar-Generator",
+            "TalkingHead-3D",
+        ],
+    },
+    "Arabic-English Models": [
+        "aubmindlab/bert-base-arabertv2",
+        "aubmindlab/aragpt2-base",
+        "aubmindlab/aragpt2-medium",
+        "CAMeL-Lab/bert-base-arabic-camelbert-mix",
+        "asafaya/bert-base-arabic",
+        "UBC-NLP/MARBERT",
+        "UBC-NLP/ARBERTv2",
+        "facebook/nllb-200-3.3B",
+        "facebook/m2m100_1.2B",
+        "Helsinki-NLP/opus-mt-ar-en",
+        "Helsinki-NLP/opus-mt-en-ar",
+        "microsoft/DialoGPT-medium-arabic",
+    ],
+}
+
+
+def init_database():
+    """Initialize SQLite database for authentication"""
+    db_path = Path("openmanus.db")
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+
+    # Create users table
+    cursor.execute(
+        """
+    CREATE TABLE IF NOT EXISTS users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        mobile_number TEXT UNIQUE NOT NULL,
+        full_name TEXT NOT NULL,
+        password_hash TEXT NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        last_login TIMESTAMP,
+        is_active BOOLEAN DEFAULT 1
+    )
+    """
+    )
+
+    # Create sessions table
+    cursor.execute(
+        """
+    CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        user_id INTEGER NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        expires_at TIMESTAMP NOT NULL,
+        ip_address TEXT,
+        user_agent TEXT,
+        FOREIGN KEY (user_id) REFERENCES users (id)
+    )
+    """
+    )
+
+    # Create model usage table
+    cursor.execute(
+        """
+    CREATE TABLE IF NOT EXISTS model_usage (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id INTEGER,
+        model_name TEXT NOT NULL,
+        category TEXT NOT NULL,
+        input_text TEXT,
+        output_text TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        processing_time REAL,
+        FOREIGN KEY (user_id) REFERENCES users (id)
+    )
+    """
+    )
+
+    conn.commit()
+    conn.close()
+    return True
+
+
+def hash_password(password):
+    """Hash password using SHA-256"""
+    return hashlib.sha256(password.encode()).hexdigest()
+
+
+def signup_user(mobile, name, password, confirm_password):
+    """User registration with mobile number"""
+    if not all([mobile, name, password, confirm_password]):
+        return "❌ Please fill in all fields"
+
+    if password != confirm_password:
+        return "❌ Passwords do not match"
+
+    if len(password) < 6:
+        return "❌ Password must be at least 6 characters"
+
+    # Validate mobile number
+    if not mobile.replace("+", "").replace("-", "").replace(" ", "").isdigit():
+        return "❌ Please enter a valid mobile number"
+
+    try:
+        conn = sqlite3.connect("openmanus.db")
+        cursor = conn.cursor()
+
+        # Check if mobile number already exists
+        cursor.execute("SELECT id FROM users WHERE mobile_number = ?", (mobile,))
+        if cursor.fetchone():
+            conn.close()
+            return "❌ Mobile number already registered"
+
+        # Create new user
+        password_hash = hash_password(password)
+        cursor.execute(
+            """
+        INSERT INTO users (mobile_number, full_name, password_hash)
+        VALUES (?, ?, ?)
+        """,
+            (mobile, name, password_hash),
+        )
+
+        conn.commit()
+        conn.close()
+
+        return f"✅ Account created successfully for {name}! Welcome to OpenManus Platform."
+
+    except Exception as e:
+        return f"❌ Registration failed: {str(e)}"
+
+
+def login_user(mobile, password):
+    """User authentication"""
+    if not mobile or not password:
+        return "❌ Please provide mobile number and password"
+
+    try:
+        conn = sqlite3.connect("openmanus.db")
+        cursor = conn.cursor()
+
+        # Verify credentials
+        password_hash = hash_password(password)
+        cursor.execute(
+            """
+        SELECT id, full_name FROM users
+        WHERE mobile_number = ? AND password_hash = ? AND is_active = 1
+        """,
+            (mobile, password_hash),
+        )
+
+        user = cursor.fetchone()
+        if user:
+            # Update last login
+            cursor.execute(
+                """
+            UPDATE users SET last_login = CURRENT_TIMESTAMP WHERE id = ?
+            """,
+                (user[0],),
+            )
+            conn.commit()
+            conn.close()
+
+            return f"✅ Welcome back, {user[1]}! Login successful."
+        else:
+            conn.close()
+            return "❌ Invalid mobile number or password"
+
+    except Exception as e:
+        return f"❌ Login failed: {str(e)}"
+
+
+def use_ai_model(model_name, input_text, user_session="guest"):
+    """Intelligently route AI model usage based on model type"""
+    if not input_text.strip():
+        return "Please enter some text for the AI model to process."
+
+    # Intelligent response templates based on model category
+    response_templates = {
+        "text": f"🧠 {model_name} processed: '{input_text}'\n\n✨ AI Response: This is a simulated response from the {model_name} model. In production, this would connect to the actual model API.",
+        "image_gen": f"🎨 {model_name} generating image: '{input_text}'\n\n📸 Output: High-quality image generated based on your prompt (simulated)",
+        "image_edit": f"✏️ {model_name} editing image: '{input_text}'\n\n�️ Output: Image manipulation complete with your instructions applied (simulated)",
+        "video": f"🎬 {model_name} creating video: '{input_text}'\n\n🎥 Output: Video generated/animated successfully (simulated)",
+        "audio": f"🎵 {model_name} audio processing: '{input_text}'\n\n🔊 Output: Audio generated/transcribed (simulated)",
+        "education": f"🎓 {model_name} teaching: '{input_text}'\n\n📚 AI Teacher Response: Step-by-step explanation with examples (simulated)",
+        "software_engineer": f"💻 {model_name} coding solution: '{input_text}'\n\n🚀 Software Engineer Agent: Production-ready code with best practices, error handling, and documentation (simulated)",
+        "multimodal": f"🤖 {model_name} multimodal processing: '{input_text}'\n\n🎯 Output: Combined AI analysis complete (simulated)",
+    }
+
+    # Intelligent model routing - Agent determines the best approach
+    model_lower = model_name.lower()
+
+    # Software Engineer Agent (production code, architecture, DevOps)
+    if any(x in model_lower for x in ["codellama", "starcoder", "codegen", "replit", "polycoder", "stablelm", "hermes"]):
+        response_type = "software_engineer"
+
+    # Image Editing Agent (separate from generation)
+    elif any(x in model_lower for x in ["pix2pix", "inpaint", "controlnet", "photomaker", "instantid", "refiner"]):
+        response_type = "image_edit"
+
+    # Image Generation Agent
+    elif any(x in model_lower for x in ["flux", "diffusion", "stable-diffusion", "sdxl", "kandinsky", "midjourney"]):
+        response_type = "image_gen"
+
+    # Education Agent (Math, Language Learning, Teaching - NOT coding)
+    elif any(x in model_lower for x in ["math", "teacher", "education", "nllb", "translate", "wizard"]) and "coder" not in model_lower:
+        response_type = "education"
+
+    # Coder Agent (Qwen/DeepSeek coder models)
+    elif "coder" in model_lower:
+        response_type = "software_engineer"
+
+    # Audio Agent
+    elif any(x in model_lower for x in ["tts", "speech", "audio", "whisper", "wav2vec", "bark", "speecht5"]):
+        response_type = "audio"
+
+    # Face Processing Agent
+    elif any(x in model_lower for x in ["face", "avatar", "talking", "wav2lip", "gfpgan", "codeformer", "insight"]):
+        response_type = "multimodal"
+
+    # Multimodal Agent (Vision-Language)
+    elif any(x in model_lower for x in ["vl", "blip", "vision", "llava", "vqa", "multimodal"]):
+        response_type = "multimodal"
+
+    # Text Generation Agent (default)
+    else:
+        response_type = "text"
+
+    return response_templates[response_type]
+
+
+def get_cloudflare_status():
+    """Get Cloudflare services status"""
+    services = []
+
+    if CLOUDFLARE_CONFIG["d1_database_id"]:
+        services.append("✅ D1 Database Connected")
+    else:
+        services.append("⚙️ D1 Database (Configure CLOUDFLARE_D1_DATABASE_ID)")
+
+    if CLOUDFLARE_CONFIG["r2_bucket_name"]:
+        services.append("✅ R2 Storage Connected")
+    else:
+        services.append("⚙️ R2 Storage (Configure CLOUDFLARE_R2_BUCKET_NAME)")
+
+    if CLOUDFLARE_CONFIG["kv_namespace_id"]:
+        services.append("✅ KV Cache Connected")
+    else:
+        services.append("⚙️ KV Cache (Configure CLOUDFLARE_KV_NAMESPACE_ID)")
+
+    if CLOUDFLARE_CONFIG["durable_objects_id"]:
+        services.append("✅ Durable Objects Connected")
+    else:
+        services.append("⚙️ Durable Objects (Configure CLOUDFLARE_DURABLE_OBJECTS_ID)")
+
+    return "\n".join(services)
+
+
+# Initialize database
+init_database()
+
+# Create Gradio interface
+with gr.Blocks(
+    title="OpenManus - Complete AI Platform",
+    theme=gr.themes.Soft(),
+    css="""
+    .container { max-width: 1400px; margin: 0 auto; }
+    .header { text-align: center; padding: 25px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 15px; margin-bottom: 25px; }
+    .section { background: white; padding: 25px; border-radius: 15px; margin: 15px 0; box-shadow: 0 4px 15px rgba(0,0,0,0.1); }
+    """,
+) as app:
+
+    # Header
+    gr.HTML(
+        """
+    <div class="header">
+        <h1>🤖 OpenManus - Complete AI Platform</h1>
+        <p><strong>Mobile Authentication + 200+ AI Models + Cloudflare Services</strong></p>
+        <p>🧠 Qwen & DeepSeek | 🖼️ Image Processing | 🎵 TTS/STT | 👤 Face Swap | 🌍 Arabic-English | ☁️ Cloud Integration</p>
+    </div>
+    """
+    )
+
+    with gr.Row():
+        # Authentication Section
+        with gr.Column(scale=1, elem_classes="section"):
+            gr.Markdown("## 🔐 Authentication System")
+
+            with gr.Tab("Sign Up"):
+                gr.Markdown("### Create New Account")
+                signup_mobile = gr.Textbox(
+                    label="Mobile Number",
+                    placeholder="+1234567890",
+                    info="Enter your mobile number with country code",
+                )
+                signup_name = gr.Textbox(
+                    label="Full Name", placeholder="Your full name"
+                )
+                signup_password = gr.Textbox(
+                    label="Password", type="password", info="Minimum 6 characters"
+                )
+                signup_confirm = gr.Textbox(label="Confirm Password", type="password")
+                signup_btn = gr.Button("Create Account", variant="primary")
+                signup_result = gr.Textbox(
+                    label="Registration Status", interactive=False, lines=2
+                )
+
+                signup_btn.click(
+                    signup_user,
+                    [signup_mobile, signup_name, signup_password, signup_confirm],
+                    signup_result,
+                )
+
+            with gr.Tab("Login"):
+                gr.Markdown("### Access Your Account")
+                login_mobile = gr.Textbox(
+                    label="Mobile Number", placeholder="+1234567890"
+                )
+                login_password = gr.Textbox(label="Password", type="password")
+                login_btn = gr.Button("Login", variant="primary")
+                login_result = gr.Textbox(
+                    label="Login Status", interactive=False, lines=2
+                )
+
+                login_btn.click(
+                    login_user, [login_mobile, login_password], login_result
+                )
+
+        # AI Models Section
+        with gr.Column(scale=2, elem_classes="section"):
+            gr.Markdown("## 🤖 AI Models Hub (200+ Models)")
+
+            with gr.Tab("Text Generation"):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Qwen Models (35 models)")
+                        qwen_model = gr.Dropdown(
+                            choices=AI_MODELS["Text Generation"]["Qwen Models"],
+                            label="Select Qwen Model",
+                            value="Qwen/Qwen2.5-72B-Instruct",
+                        )
+                        qwen_input = gr.Textbox(
+                            label="Input Text",
+                            placeholder="Enter your prompt for Qwen...",
+                            lines=3,
+                        )
+                        qwen_btn = gr.Button("Generate with Qwen")
+                        qwen_output = gr.Textbox(
+                            label="Qwen Response", lines=5, interactive=False
+                        )
+                        qwen_btn.click(
+                            use_ai_model, [qwen_model, qwen_input], qwen_output
+                        )
+
+                    with gr.Column():
+                        gr.Markdown("### DeepSeek Models (17 models)")
+                        deepseek_model = gr.Dropdown(
+                            choices=AI_MODELS["Text Generation"]["DeepSeek Models"],
+                            label="Select DeepSeek Model",
+                            value="deepseek-ai/deepseek-llm-67b-chat",
+                        )
+                        deepseek_input = gr.Textbox(
+                            label="Input Text",
+                            placeholder="Enter your prompt for DeepSeek...",
+                            lines=3,
+                        )
+                        deepseek_btn = gr.Button("Generate with DeepSeek")
+                        deepseek_output = gr.Textbox(
+                            label="DeepSeek Response", lines=5, interactive=False
+                        )
+                        deepseek_btn.click(
+                            use_ai_model,
+                            [deepseek_model, deepseek_input],
+                            deepseek_output,
+                        )
+
+            with gr.Tab("Image Processing"):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Image Generation")
+                        img_gen_model = gr.Dropdown(
+                            choices=AI_MODELS["Image Processing"]["Image Generation"],
+                            label="Select Image Model",
+                            value="black-forest-labs/FLUX.1-dev",
+                        )
+                        img_prompt = gr.Textbox(
+                            label="Image Prompt",
+                            placeholder="Describe the image you want to generate...",
+                            lines=2,
+                        )
+                        img_gen_btn = gr.Button("Generate Image")
+                        img_gen_output = gr.Textbox(
+                            label="Generation Status", lines=4, interactive=False
+                        )
+                        img_gen_btn.click(
+                            use_ai_model, [img_gen_model, img_prompt], img_gen_output
+                        )
+
+                    with gr.Column():
+                        gr.Markdown("### Face Processing & Editing")
+                        face_model = gr.Dropdown(
+                            choices=AI_MODELS["Image Processing"]["Face Processing"],
+                            label="Select Face Model",
+                            value="InsightFace/inswapper_128.onnx",
+                        )
+                        face_input = gr.Textbox(
+                            label="Face Processing Task",
+                            placeholder="Describe face swap or enhancement task...",
+                            lines=2,
+                        )
+                        face_btn = gr.Button("Process Face")
+                        face_output = gr.Textbox(
+                            label="Processing Status", lines=4, interactive=False
+                        )
+                        face_btn.click(
+                            use_ai_model, [face_model, face_input], face_output
+                        )
+
+            with gr.Tab("Image Editing"):
+                gr.Markdown("### ✏️ Advanced Image Editing & Manipulation (15+ models)")
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Image Editing Models")
+                        edit_model = gr.Dropdown(
+                            choices=AI_MODELS["Image Processing"]["Image Editing"],
+                            label="Select Image Editing Model",
+                            value="timbrooks/instruct-pix2pix",
+                        )
+                        edit_input = gr.Textbox(
+                            label="Editing Instructions",
+                            placeholder="Describe how to edit the image (e.g., 'make it winter', 'remove background')...",
+                            lines=3,
+                        )
+                        edit_btn = gr.Button("Edit Image")
+                        edit_output = gr.Textbox(
+                            label="Editing Status", lines=4, interactive=False
+                        )
+                        edit_btn.click(
+                            use_ai_model, [edit_model, edit_input], edit_output
+                        )
+
+            with gr.Tab("Video Generation"):
+                gr.Markdown("### 🎬 Video Generation & Editing (18+ models)")
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Text-to-Video")
+                        video_text_model = gr.Dropdown(
+                            choices=AI_MODELS["Video Generation"]["Text-to-Video"],
+                            label="Select Text-to-Video Model",
+                            value="ali-vilab/text-to-video-ms-1.7b",
+                        )
+                        video_text_input = gr.Textbox(
+                            label="Video Description",
+                            placeholder="Describe the video you want to generate...",
+                            lines=3,
+                        )
+                        video_text_btn = gr.Button("Generate Video from Text")
+                        video_text_output = gr.Textbox(
+                            label="Video Generation Status", lines=4, interactive=False
+                        )
+                        video_text_btn.click(
+                            use_ai_model,
+                            [video_text_model, video_text_input],
+                            video_text_output,
+                        )
+
+                    with gr.Column():
+                        gr.Markdown("### Image-to-Video & Video Editing")
+                        video_img_model = gr.Dropdown(
+                            choices=AI_MODELS["Video Generation"]["Image-to-Video"],
+                            label="Select Image-to-Video Model",
+                            value="stabilityai/stable-video-diffusion-img2vid",
+                        )
+                        video_img_input = gr.Textbox(
+                            label="Animation Instructions",
+                            placeholder="Describe how to animate the image or edit video...",
+                            lines=3,
+                        )
+                        video_img_btn = gr.Button("Animate Image")
+                        video_img_output = gr.Textbox(
+                            label="Video Processing Status", lines=4, interactive=False
+                        )
+                        video_img_btn.click(
+                            use_ai_model,
+                            [video_img_model, video_img_input],
+                            video_img_output,
+                        )
+
+            with gr.Tab("AI Teacher & Education"):
+                gr.Markdown(
+                    "### 🎓 AI Teacher - Math, Coding, Languages & More (20+ models)"
+                )
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Math & Science Tutor")
+                        math_model = gr.Dropdown(
+                            choices=AI_MODELS["AI Teacher & Education"][
+                                "Math & Science"
+                            ],
+                            label="Select Math/Science Model",
+                            value="Qwen/Qwen2.5-Math-72B-Instruct",
+                        )
+                        math_input = gr.Textbox(
+                            label="Math/Science Question",
+                            placeholder="Ask a math or science question...",
+                            lines=3,
+                        )
+                        math_btn = gr.Button("Solve with AI Teacher")
+                        math_output = gr.Textbox(
+                            label="Solution & Explanation", lines=6, interactive=False
+                        )
+                        math_btn.click(
+                            use_ai_model, [math_model, math_input], math_output
+                        )
+
+                    with gr.Column():
+                        gr.Markdown("### Coding Tutor & Language Learning")
+                        edu_model = gr.Dropdown(
+                            choices=AI_MODELS["AI Teacher & Education"]["Coding Tutor"],
+                            label="Select Educational Model",
+                            value="Qwen/Qwen2.5-Coder-32B-Instruct",
+                        )
+                        edu_input = gr.Textbox(
+                            label="Learning Request",
+                            placeholder="Ask for coding help or language learning...",
+                            lines=3,
+                        )
+                        edu_btn = gr.Button("Learn with AI")
+                        edu_output = gr.Textbox(
+                            label="Educational Response", lines=6, interactive=False
+                        )
+                        edu_btn.click(use_ai_model, [edu_model, edu_input], edu_output)
+
+            with gr.Tab("Software Engineer Agent"):
+                gr.Markdown(
+                    "### 💻 Software Engineer Agent - Production Code, Architecture & DevOps (27+ models)"
+                )
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Code Generation & Development")
+                        code_gen_model = gr.Dropdown(
+                            choices=AI_MODELS["Software Engineer Agent"][
+                                "Code Generation"
+                            ],
+                            label="Select Code Generation Model",
+                            value="Qwen/Qwen2.5-Coder-32B-Instruct",
+                        )
+                        code_gen_input = gr.Textbox(
+                            label="Coding Task",
+                            placeholder="Describe the code you need (e.g., 'Create a REST API', 'Build a database schema')...",
+                            lines=4,
+                        )
+                        code_gen_btn = gr.Button("Generate Production Code")
+                        code_gen_output = gr.Textbox(
+                            label="Generated Code & Documentation",
+                            lines=8,
+                            interactive=False,
+                        )
+                        code_gen_btn.click(
+                            use_ai_model,
+                            [code_gen_model, code_gen_input],
+                            code_gen_output,
+                        )
+
+                    with gr.Column():
+                        gr.Markdown("### Code Review & Analysis")
+                        code_review_model = gr.Dropdown(
+                            choices=AI_MODELS["Software Engineer Agent"][
+                                "Code Analysis & Review"
+                            ],
+                            label="Select Code Review Model",
+                            value="bigcode/starcoder2-15b-instruct-v0.1",
+                        )
+                        code_review_input = gr.Textbox(
+                            label="Code to Review",
+                            placeholder="Paste your code for review, optimization, or debugging...",
+                            lines=4,
+                        )
+                        code_review_btn = gr.Button("Review Code")
+                        code_review_output = gr.Textbox(
+                            label="Code Review & Suggestions",
+                            lines=8,
+                            interactive=False,
+                        )
+                        code_review_btn.click(
+                            use_ai_model,
+                            [code_review_model, code_review_input],
+                            code_review_output,
+                        )
+
+            with gr.Tab("Audio Processing"):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Text-to-Speech (15 models)")
+                        tts_model = gr.Dropdown(
+                            choices=AI_MODELS["Audio Processing"]["Text-to-Speech"],
+                            label="Select TTS Model",
+                            value="microsoft/speecht5_tts",
+                        )
+                        tts_text = gr.Textbox(
+                            label="Text to Speak",
+                            placeholder="Enter text to convert to speech...",
+                            lines=3,
+                        )
+                        tts_btn = gr.Button("Generate Speech")
+                        tts_output = gr.Textbox(
+                            label="TTS Status", lines=4, interactive=False
+                        )
+                        tts_btn.click(use_ai_model, [tts_model, tts_text], tts_output)
+
+                    with gr.Column():
+                        gr.Markdown("### Speech-to-Text (15 models)")
+                        stt_model = gr.Dropdown(
+                            choices=AI_MODELS["Audio Processing"]["Speech-to-Text"],
+                            label="Select STT Model",
+                            value="openai/whisper-large-v3",
+                        )
+                        stt_input = gr.Textbox(
+                            label="Audio Description",
+                            placeholder="Describe audio file to transcribe...",
+                            lines=3,
+                        )
+                        stt_btn = gr.Button("Transcribe Audio")
+                        stt_output = gr.Textbox(
+                            label="STT Status", lines=4, interactive=False
+                        )
+                        stt_btn.click(use_ai_model, [stt_model, stt_input], stt_output)
+
+            with gr.Tab("Multimodal & Avatars"):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Vision-Language Models")
+                        vl_model = gr.Dropdown(
+                            choices=AI_MODELS["Multimodal AI"]["Vision-Language"],
+                            label="Select VL Model",
+                            value="liuhaotian/llava-v1.6-34b",
+                        )
+                        vl_input = gr.Textbox(
+                            label="Vision-Language Task",
+                            placeholder="Describe image analysis or VQA task...",
+                            lines=3,
+                        )
+                        vl_btn = gr.Button("Process with VL Model")
+                        vl_output = gr.Textbox(
+                            label="VL Response", lines=4, interactive=False
+                        )
+                        vl_btn.click(use_ai_model, [vl_model, vl_input], vl_output)
+
+                    with gr.Column():
+                        gr.Markdown("### Talking Avatars")
+                        avatar_model = gr.Dropdown(
+                            choices=AI_MODELS["Multimodal AI"]["Talking Avatars"],
+                            label="Select Avatar Model",
+                            value="Wav2Lip-HD",
+                        )
+                        avatar_input = gr.Textbox(
+                            label="Avatar Generation Task",
+                            placeholder="Describe talking avatar or lip-sync task...",
+                            lines=3,
+                        )
+                        avatar_btn = gr.Button("Generate Avatar")
+                        avatar_output = gr.Textbox(
+                            label="Avatar Status", lines=4, interactive=False
+                        )
+                        avatar_btn.click(
+                            use_ai_model, [avatar_model, avatar_input], avatar_output
+                        )
+
+            with gr.Tab("Arabic-English"):
+                gr.Markdown("### Arabic-English Interactive Models (12 models)")
+                arabic_model = gr.Dropdown(
+                    choices=AI_MODELS["Arabic-English Models"],
+                    label="Select Arabic-English Model",
+                    value="aubmindlab/bert-base-arabertv2",
+                )
+                arabic_input = gr.Textbox(
+                    label="Text (Arabic or English)",
+                    placeholder="أدخل النص باللغة العربية أو الإنجليزية / Enter text in Arabic or English...",
+                    lines=4,
+                )
+                arabic_btn = gr.Button("Process Arabic-English")
+                arabic_output = gr.Textbox(
+                    label="Processing Result", lines=6, interactive=False
+                )
+                arabic_btn.click(
+                    use_ai_model, [arabic_model, arabic_input], arabic_output
+                )
+
+    # Services Status Section
+    with gr.Row():
+        with gr.Column(elem_classes="section"):
+            gr.Markdown("## ☁️ Cloudflare Services Integration")
+
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Services Status")
+                    services_status = gr.Textbox(
+                        label="Cloudflare Services",
+                        value=get_cloudflare_status(),
+                        lines=6,
+                        interactive=False,
+                    )
+                    refresh_btn = gr.Button("Refresh Status")
+                    refresh_btn.click(
+                        lambda: get_cloudflare_status(), outputs=services_status
+                    )
+
+                with gr.Column():
+                    gr.Markdown("### Configuration")
+                    gr.HTML(
+                        """
+                    <div style="background: #f0f8ff; padding: 15px; border-radius: 10px;">
+                        <h4>Environment Variables:</h4>
+                        <ul>
+                            <li><code>CLOUDFLARE_API_TOKEN</code> - API authentication</li>
+                            <li><code>CLOUDFLARE_ACCOUNT_ID</code> - Account identifier</li>
+                            <li><code>CLOUDFLARE_D1_DATABASE_ID</code> - D1 database</li>
+                            <li><code>CLOUDFLARE_R2_BUCKET_NAME</code> - R2 storage</li>
+                            <li><code>CLOUDFLARE_KV_NAMESPACE_ID</code> - KV cache</li>
+                            <li><code>CLOUDFLARE_DURABLE_OBJECTS_ID</code> - Durable objects</li>
+                        </ul>
+                    </div>
+                    """
+                    )
+
+    # Footer Status
+    gr.HTML(
+        """
+    <div style="background: linear-gradient(45deg, #f0f8ff 0%, #e6f3ff 100%); padding: 20px; border-radius: 15px; margin-top: 25px; text-align: center;">
+        <h3>📊 Platform Status</h3>
+        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin: 15px 0;">
+            <div>✅ <strong>Authentication:</strong> Active</div>
+            <div>🧠 <strong>AI Models:</strong> 200+ Ready</div>
+            <div>🖼️ <strong>Image Processing:</strong> Available</div>
+            <div>🎵 <strong>Audio AI:</strong> Enabled</div>
+            <div>👤 <strong>Face/Avatar:</strong> Ready</div>
+            <div>🌍 <strong>Arabic-English:</strong> Supported</div>
+            <div>☁️ <strong>Cloudflare:</strong> Configurable</div>
+            <div>🚀 <strong>Platform:</strong> Production Ready</div>
+        </div>
+        <p><em>Complete AI Platform successfully deployed on HuggingFace Spaces!</em></p>
+    </div>
+    """
+    )
+
+# Launch the app
+app.launch()

app/__init__.py

@@ -0,0 +1,10 @@
+# Python version check: 3.11-3.13
+import sys
+
+
+if sys.version_info < (3, 11) or sys.version_info > (3, 13):
+    print(
+        "Warning: Unsupported Python version {ver}, please use 3.11-3.13".format(
+            ver=".".join(map(str, sys.version_info))
+        )
+    )

app/agent/__init__.py

@@ -0,0 +1,16 @@
+from app.agent.base import BaseAgent
+from app.agent.browser import BrowserAgent
+from app.agent.mcp import MCPAgent
+from app.agent.react import ReActAgent
+from app.agent.swe import SWEAgent
+from app.agent.toolcall import ToolCallAgent
+
+
+__all__ = [
+    "BaseAgent",
+    "BrowserAgent",
+    "ReActAgent",
+    "SWEAgent",
+    "ToolCallAgent",
+    "MCPAgent",
+]

app/agent/base.py

@@ -0,0 +1,196 @@
+from abc import ABC, abstractmethod
+from contextlib import asynccontextmanager
+from typing import List, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+from app.llm import LLM
+from app.logger import logger
+from app.sandbox.client import SANDBOX_CLIENT
+from app.schema import ROLE_TYPE, AgentState, Memory, Message
+
+
+class BaseAgent(BaseModel, ABC):
+    """Abstract base class for managing agent state and execution.
+
+    Provides foundational functionality for state transitions, memory management,
+    and a step-based execution loop. Subclasses must implement the `step` method.
+    """
+
+    # Core attributes
+    name: str = Field(..., description="Unique name of the agent")
+    description: Optional[str] = Field(None, description="Optional agent description")
+
+    # Prompts
+    system_prompt: Optional[str] = Field(
+        None, description="System-level instruction prompt"
+    )
+    next_step_prompt: Optional[str] = Field(
+        None, description="Prompt for determining next action"
+    )
+
+    # Dependencies
+    llm: LLM = Field(default_factory=LLM, description="Language model instance")
+    memory: Memory = Field(default_factory=Memory, description="Agent's memory store")
+    state: AgentState = Field(
+        default=AgentState.IDLE, description="Current agent state"
+    )
+
+    # Execution control
+    max_steps: int = Field(default=10, description="Maximum steps before termination")
+    current_step: int = Field(default=0, description="Current step in execution")
+
+    duplicate_threshold: int = 2
+
+    class Config:
+        arbitrary_types_allowed = True
+        extra = "allow"  # Allow extra fields for flexibility in subclasses
+
+    @model_validator(mode="after")
+    def initialize_agent(self) -> "BaseAgent":
+        """Initialize agent with default settings if not provided."""
+        if self.llm is None or not isinstance(self.llm, LLM):
+            self.llm = LLM(config_name=self.name.lower())
+        if not isinstance(self.memory, Memory):
+            self.memory = Memory()
+        return self
+
+    @asynccontextmanager
+    async def state_context(self, new_state: AgentState):
+        """Context manager for safe agent state transitions.
+
+        Args:
+            new_state: The state to transition to during the context.
+
+        Yields:
+            None: Allows execution within the new state.
+
+        Raises:
+            ValueError: If the new_state is invalid.
+        """
+        if not isinstance(new_state, AgentState):
+            raise ValueError(f"Invalid state: {new_state}")
+
+        previous_state = self.state
+        self.state = new_state
+        try:
+            yield
+        except Exception as e:
+            self.state = AgentState.ERROR  # Transition to ERROR on failure
+            raise e
+        finally:
+            self.state = previous_state  # Revert to previous state
+
+    def update_memory(
+        self,
+        role: ROLE_TYPE,  # type: ignore
+        content: str,
+        base64_image: Optional[str] = None,
+        **kwargs,
+    ) -> None:
+        """Add a message to the agent's memory.
+
+        Args:
+            role: The role of the message sender (user, system, assistant, tool).
+            content: The message content.
+            base64_image: Optional base64 encoded image.
+            **kwargs: Additional arguments (e.g., tool_call_id for tool messages).
+
+        Raises:
+            ValueError: If the role is unsupported.
+        """
+        message_map = {
+            "user": Message.user_message,
+            "system": Message.system_message,
+            "assistant": Message.assistant_message,
+            "tool": lambda content, **kw: Message.tool_message(content, **kw),
+        }
+
+        if role not in message_map:
+            raise ValueError(f"Unsupported message role: {role}")
+
+        # Create message with appropriate parameters based on role
+        kwargs = {"base64_image": base64_image, **(kwargs if role == "tool" else {})}
+        self.memory.add_message(message_map[role](content, **kwargs))
+
+    async def run(self, request: Optional[str] = None) -> str:
+        """Execute the agent's main loop asynchronously.
+
+        Args:
+            request: Optional initial user request to process.
+
+        Returns:
+            A string summarizing the execution results.
+
+        Raises:
+            RuntimeError: If the agent is not in IDLE state at start.
+        """
+        if self.state != AgentState.IDLE:
+            raise RuntimeError(f"Cannot run agent from state: {self.state}")
+
+        if request:
+            self.update_memory("user", request)
+
+        results: List[str] = []
+        async with self.state_context(AgentState.RUNNING):
+            while (
+                self.current_step < self.max_steps and self.state != AgentState.FINISHED
+            ):
+                self.current_step += 1
+                logger.info(f"Executing step {self.current_step}/{self.max_steps}")
+                step_result = await self.step()
+
+                # Check for stuck state
+                if self.is_stuck():
+                    self.handle_stuck_state()
+
+                results.append(f"Step {self.current_step}: {step_result}")
+
+            if self.current_step >= self.max_steps:
+                self.current_step = 0
+                self.state = AgentState.IDLE
+                results.append(f"Terminated: Reached max steps ({self.max_steps})")
+        await SANDBOX_CLIENT.cleanup()
+        return "\n".join(results) if results else "No steps executed"
+
+    @abstractmethod
+    async def step(self) -> str:
+        """Execute a single step in the agent's workflow.
+
+        Must be implemented by subclasses to define specific behavior.
+        """
+
+    def handle_stuck_state(self):
+        """Handle stuck state by adding a prompt to change strategy"""
+        stuck_prompt = "\
+        Observed duplicate responses. Consider new strategies and avoid repeating ineffective paths already attempted."
+        self.next_step_prompt = f"{stuck_prompt}\n{self.next_step_prompt}"
+        logger.warning(f"Agent detected stuck state. Added prompt: {stuck_prompt}")
+
+    def is_stuck(self) -> bool:
+        """Check if the agent is stuck in a loop by detecting duplicate content"""
+        if len(self.memory.messages) < 2:
+            return False
+
+        last_message = self.memory.messages[-1]
+        if not last_message.content:
+            return False
+
+        # Count identical content occurrences
+        duplicate_count = sum(
+            1
+            for msg in reversed(self.memory.messages[:-1])
+            if msg.role == "assistant" and msg.content == last_message.content
+        )
+
+        return duplicate_count >= self.duplicate_threshold
+
+    @property
+    def messages(self) -> List[Message]:
+        """Retrieve a list of messages from the agent's memory."""
+        return self.memory.messages
+
+    @messages.setter
+    def messages(self, value: List[Message]):
+        """Set the list of messages in the agent's memory."""
+        self.memory.messages = value

app/agent/manus.py

@@ -0,0 +1,165 @@
+from typing import Dict, List, Optional
+
+from pydantic import Field, model_validator
+
+from app.agent.browser import BrowserContextHelper
+from app.agent.toolcall import ToolCallAgent
+from app.config import config
+from app.logger import logger
+from app.prompt.manus import NEXT_STEP_PROMPT, SYSTEM_PROMPT
+from app.tool import Terminate, ToolCollection
+from app.tool.ask_human import AskHuman
+from app.tool.browser_use_tool import BrowserUseTool
+from app.tool.mcp import MCPClients, MCPClientTool
+from app.tool.python_execute import PythonExecute
+from app.tool.str_replace_editor import StrReplaceEditor
+
+
+class Manus(ToolCallAgent):
+    """A versatile general-purpose agent with support for both local and MCP tools."""
+
+    name: str = "Manus"
+    description: str = "A versatile agent that can solve various tasks using multiple tools including MCP-based tools"
+
+    system_prompt: str = SYSTEM_PROMPT.format(directory=config.workspace_root)
+    next_step_prompt: str = NEXT_STEP_PROMPT
+
+    max_observe: int = 10000
+    max_steps: int = 20
+
+    # MCP clients for remote tool access
+    mcp_clients: MCPClients = Field(default_factory=MCPClients)
+
+    # Add general-purpose tools to the tool collection
+    available_tools: ToolCollection = Field(
+        default_factory=lambda: ToolCollection(
+            PythonExecute(),
+            BrowserUseTool(),
+            StrReplaceEditor(),
+            AskHuman(),
+            Terminate(),
+        )
+    )
+
+    special_tool_names: list[str] = Field(default_factory=lambda: [Terminate().name])
+    browser_context_helper: Optional[BrowserContextHelper] = None
+
+    # Track connected MCP servers
+    connected_servers: Dict[str, str] = Field(
+        default_factory=dict
+    )  # server_id -> url/command
+    _initialized: bool = False
+
+    @model_validator(mode="after")
+    def initialize_helper(self) -> "Manus":
+        """Initialize basic components synchronously."""
+        self.browser_context_helper = BrowserContextHelper(self)
+        return self
+
+    @classmethod
+    async def create(cls, **kwargs) -> "Manus":
+        """Factory method to create and properly initialize a Manus instance."""
+        instance = cls(**kwargs)
+        await instance.initialize_mcp_servers()
+        instance._initialized = True
+        return instance
+
+    async def initialize_mcp_servers(self) -> None:
+        """Initialize connections to configured MCP servers."""
+        for server_id, server_config in config.mcp_config.servers.items():
+            try:
+                if server_config.type == "sse":
+                    if server_config.url:
+                        await self.connect_mcp_server(server_config.url, server_id)
+                        logger.info(
+                            f"Connected to MCP server {server_id} at {server_config.url}"
+                        )
+                elif server_config.type == "stdio":
+                    if server_config.command:
+                        await self.connect_mcp_server(
+                            server_config.command,
+                            server_id,
+                            use_stdio=True,
+                            stdio_args=server_config.args,
+                        )
+                        logger.info(
+                            f"Connected to MCP server {server_id} using command {server_config.command}"
+                        )
+            except Exception as e:
+                logger.error(f"Failed to connect to MCP server {server_id}: {e}")
+
+    async def connect_mcp_server(
+        self,
+        server_url: str,
+        server_id: str = "",
+        use_stdio: bool = False,
+        stdio_args: List[str] = None,
+    ) -> None:
+        """Connect to an MCP server and add its tools."""
+        if use_stdio:
+            await self.mcp_clients.connect_stdio(
+                server_url, stdio_args or [], server_id
+            )
+            self.connected_servers[server_id or server_url] = server_url
+        else:
+            await self.mcp_clients.connect_sse(server_url, server_id)
+            self.connected_servers[server_id or server_url] = server_url
+
+        # Update available tools with only the new tools from this server
+        new_tools = [
+            tool for tool in self.mcp_clients.tools if tool.server_id == server_id
+        ]
+        self.available_tools.add_tools(*new_tools)
+
+    async def disconnect_mcp_server(self, server_id: str = "") -> None:
+        """Disconnect from an MCP server and remove its tools."""
+        await self.mcp_clients.disconnect(server_id)
+        if server_id:
+            self.connected_servers.pop(server_id, None)
+        else:
+            self.connected_servers.clear()
+
+        # Rebuild available tools without the disconnected server's tools
+        base_tools = [
+            tool
+            for tool in self.available_tools.tools
+            if not isinstance(tool, MCPClientTool)
+        ]
+        self.available_tools = ToolCollection(*base_tools)
+        self.available_tools.add_tools(*self.mcp_clients.tools)
+
+    async def cleanup(self):
+        """Clean up Manus agent resources."""
+        if self.browser_context_helper:
+            await self.browser_context_helper.cleanup_browser()
+        # Disconnect from all MCP servers only if we were initialized
+        if self._initialized:
+            await self.disconnect_mcp_server()
+            self._initialized = False
+
+    async def think(self) -> bool:
+        """Process current state and decide next actions with appropriate context."""
+        if not self._initialized:
+            await self.initialize_mcp_servers()
+            self._initialized = True
+
+        original_prompt = self.next_step_prompt
+        recent_messages = self.memory.messages[-3:] if self.memory.messages else []
+        browser_in_use = any(
+            tc.function.name == BrowserUseTool().name
+            for msg in recent_messages
+            if msg.tool_calls
+            for tc in msg.tool_calls
+        )
+
+        if browser_in_use:
+            self.next_step_prompt = (
+                await self.browser_context_helper.format_next_step_prompt()
+            )
+
+        result = await super().think()
+
+        # Restore original prompt
+        self.next_step_prompt = original_prompt
+
+        return result

app/agent/toolcall.py

@@ -0,0 +1,250 @@
+import asyncio
+import json
+from typing import Any, List, Optional, Union
+
+from pydantic import Field
+
+from app.agent.react import ReActAgent
+from app.exceptions import TokenLimitExceeded
+from app.logger import logger
+from app.prompt.toolcall import NEXT_STEP_PROMPT, SYSTEM_PROMPT
+from app.schema import TOOL_CHOICE_TYPE, AgentState, Message, ToolCall, ToolChoice
+from app.tool import CreateChatCompletion, Terminate, ToolCollection
+
+
+TOOL_CALL_REQUIRED = "Tool calls required but none provided"
+
+
+class ToolCallAgent(ReActAgent):
+    """Base agent class for handling tool/function calls with enhanced abstraction"""
+
+    name: str = "toolcall"
+    description: str = "an agent that can execute tool calls."
+
+    system_prompt: str = SYSTEM_PROMPT
+    next_step_prompt: str = NEXT_STEP_PROMPT
+
+    available_tools: ToolCollection = ToolCollection(
+        CreateChatCompletion(), Terminate()
+    )
+    tool_choices: TOOL_CHOICE_TYPE = ToolChoice.AUTO  # type: ignore
+    special_tool_names: List[str] = Field(default_factory=lambda: [Terminate().name])
+
+    tool_calls: List[ToolCall] = Field(default_factory=list)
+    _current_base64_image: Optional[str] = None
+
+    max_steps: int = 30
+    max_observe: Optional[Union[int, bool]] = None
+
+    async def think(self) -> bool:
+        """Process current state and decide next actions using tools"""
+        if self.next_step_prompt:
+            user_msg = Message.user_message(self.next_step_prompt)
+            self.messages += [user_msg]
+
+        try:
+            # Get response with tool options
+            response = await self.llm.ask_tool(
+                messages=self.messages,
+                system_msgs=(
+                    [Message.system_message(self.system_prompt)]
+                    if self.system_prompt
+                    else None
+                ),
+                tools=self.available_tools.to_params(),
+                tool_choice=self.tool_choices,
+            )
+        except ValueError:
+            raise
+        except Exception as e:
+            # Check if this is a RetryError containing TokenLimitExceeded
+            if hasattr(e, "__cause__") and isinstance(e.__cause__, TokenLimitExceeded):
+                token_limit_error = e.__cause__
+                logger.error(
+                    f"🚨 Token limit error (from RetryError): {token_limit_error}"
+                )
+                self.memory.add_message(
+                    Message.assistant_message(
+                        f"Maximum token limit reached, cannot continue execution: {str(token_limit_error)}"
+                    )
+                )
+                self.state = AgentState.FINISHED
+                return False
+            raise
+
+        self.tool_calls = tool_calls = (
+            response.tool_calls if response and response.tool_calls else []
+        )
+        content = response.content if response and response.content else ""
+
+        # Log response info
+        logger.info(f"✨ {self.name}'s thoughts: {content}")
+        logger.info(
+            f"🛠️ {self.name} selected {len(tool_calls) if tool_calls else 0} tools to use"
+        )
+        if tool_calls:
+            logger.info(
+                f"🧰 Tools being prepared: {[call.function.name for call in tool_calls]}"
+            )
+            logger.info(f"🔧 Tool arguments: {tool_calls[0].function.arguments}")
+
+        try:
+            if response is None:
+                raise RuntimeError("No response received from the LLM")
+
+            # Handle different tool_choices modes
+            if self.tool_choices == ToolChoice.NONE:
+                if tool_calls:
+                    logger.warning(
+                        f"🤔 Hmm, {self.name} tried to use tools when they weren't available!"
+                    )
+                if content:
+                    self.memory.add_message(Message.assistant_message(content))
+                    return True
+                return False
+
+            # Create and add assistant message
+            assistant_msg = (
+                Message.from_tool_calls(content=content, tool_calls=self.tool_calls)
+                if self.tool_calls
+                else Message.assistant_message(content)
+            )
+            self.memory.add_message(assistant_msg)
+
+            if self.tool_choices == ToolChoice.REQUIRED and not self.tool_calls:
+                return True  # Will be handled in act()
+
+            # For 'auto' mode, continue with content if no commands but content exists
+            if self.tool_choices == ToolChoice.AUTO and not self.tool_calls:
+                return bool(content)
+
+            return bool(self.tool_calls)
+        except Exception as e:
+            logger.error(f"🚨 Oops! The {self.name}'s thinking process hit a snag: {e}")
+            self.memory.add_message(
+                Message.assistant_message(
+                    f"Error encountered while processing: {str(e)}"
+                )
+            )
+            return False
+
+    async def act(self) -> str:
+        """Execute tool calls and handle their results"""
+        if not self.tool_calls:
+            if self.tool_choices == ToolChoice.REQUIRED:
+                raise ValueError(TOOL_CALL_REQUIRED)
+
+            # Return last message content if no tool calls
+            return self.messages[-1].content or "No content or commands to execute"
+
+        results = []
+        for command in self.tool_calls:
+            # Reset base64_image for each tool call
+            self._current_base64_image = None
+
+            result = await self.execute_tool(command)
+
+            if self.max_observe:
+                result = result[: self.max_observe]
+
+            logger.info(
+                f"🎯 Tool '{command.function.name}' completed its mission! Result: {result}"
+            )
+
+            # Add tool response to memory
+            tool_msg = Message.tool_message(
+                content=result,
+                tool_call_id=command.id,
+                name=command.function.name,
+                base64_image=self._current_base64_image,
+            )
+            self.memory.add_message(tool_msg)
+            results.append(result)
+
+        return "\n\n".join(results)
+
+    async def execute_tool(self, command: ToolCall) -> str:
+        """Execute a single tool call with robust error handling"""
+        if not command or not command.function or not command.function.name:
+            return "Error: Invalid command format"
+
+        name = command.function.name
+        if name not in self.available_tools.tool_map:
+            return f"Error: Unknown tool '{name}'"
+
+        try:
+            # Parse arguments
+            args = json.loads(command.function.arguments or "{}")
+
+            # Execute the tool
+            logger.info(f"🔧 Activating tool: '{name}'...")
+            result = await self.available_tools.execute(name=name, tool_input=args)
+
+            # Handle special tools
+            await self._handle_special_tool(name=name, result=result)
+
+            # Check if result is a ToolResult with base64_image
+            if hasattr(result, "base64_image") and result.base64_image:
+                # Store the base64_image for later use in tool_message
+                self._current_base64_image = result.base64_image
+
+            # Format result for display (standard case)
+            observation = (
+                f"Observed output of cmd `{name}` executed:\n{str(result)}"
+                if result
+                else f"Cmd `{name}` completed with no output"
+            )
+
+            return observation
+        except json.JSONDecodeError:
+            error_msg = f"Error parsing arguments for {name}: Invalid JSON format"
+            logger.error(
+                f"📝 Oops! The arguments for '{name}' don't make sense - invalid JSON, arguments:{command.function.arguments}"
+            )
+            return f"Error: {error_msg}"
+        except Exception as e:
+            error_msg = f"⚠️ Tool '{name}' encountered a problem: {str(e)}"
+            logger.exception(error_msg)
+            return f"Error: {error_msg}"
+
+    async def _handle_special_tool(self, name: str, result: Any, **kwargs):
+        """Handle special tool execution and state changes"""
+        if not self._is_special_tool(name):
+            return
+
+        if self._should_finish_execution(name=name, result=result, **kwargs):
+            # Set agent state to finished
+            logger.info(f"🏁 Special tool '{name}' has completed the task!")
+            self.state = AgentState.FINISHED
+
+    @staticmethod
+    def _should_finish_execution(**kwargs) -> bool:
+        """Determine if tool execution should finish the agent"""
+        return True
+
+    def _is_special_tool(self, name: str) -> bool:
+        """Check if tool name is in special tools list"""
+        return name.lower() in [n.lower() for n in self.special_tool_names]
+
+    async def cleanup(self):
+        """Clean up resources used by the agent's tools."""
+        logger.info(f"🧹 Cleaning up resources for agent '{self.name}'...")
+        for tool_name, tool_instance in self.available_tools.tool_map.items():
+            if hasattr(tool_instance, "cleanup") and asyncio.iscoroutinefunction(
+                tool_instance.cleanup
+            ):
+                try:
+                    logger.debug(f"🧼 Cleaning up tool: {tool_name}")
+                    await tool_instance.cleanup()
+                except Exception as e:
+                    logger.error(
+                        f"🚨 Error cleaning up tool '{tool_name}': {e}", exc_info=True
+                    )
+        logger.info(f"✨ Cleanup complete for agent '{self.name}'.")
+
+    async def run(self, request: Optional[str] = None) -> str:
+        """Run the agent with cleanup when done."""
+        try:
+            return await super().run(request)
+        finally:
+            await self.cleanup()

app/auth.py

@@ -0,0 +1,205 @@
+"""
+User authentication models and validation for OpenManus
+Mobile number + password based authentication system
+"""
+
+import hashlib
+import re
+import secrets
+from datetime import datetime, timedelta
+from typing import Optional
+from dataclasses import dataclass
+from pydantic import BaseModel, validator
+
+
+class UserSignupRequest(BaseModel):
+    """User signup request model"""
+
+    full_name: str
+    mobile_number: str
+    password: str
+    confirm_password: str
+
+    @validator("full_name")
+    def validate_full_name(cls, v):
+        if not v or len(v.strip()) < 2:
+            raise ValueError("Full name must be at least 2 characters long")
+        if len(v.strip()) > 100:
+            raise ValueError("Full name must be less than 100 characters")
+        return v.strip()
+
+    @validator("mobile_number")
+    def validate_mobile_number(cls, v):
+        # Remove all non-digit characters
+        digits_only = re.sub(r"\D", "", v)
+
+        # Check if it's a valid mobile number (10-15 digits)
+        if len(digits_only) < 10 or len(digits_only) > 15:
+            raise ValueError("Mobile number must be between 10-15 digits")
+
+        # Ensure it starts with country code or local format
+        if not re.match(r"^(\+?[1-9]\d{9,14})$", digits_only):
+            raise ValueError("Invalid mobile number format")
+
+        return digits_only
+
+    @validator("password")
+    def validate_password(cls, v):
+        if len(v) < 8:
+            raise ValueError("Password must be at least 8 characters long")
+        if len(v) > 128:
+            raise ValueError("Password must be less than 128 characters")
+
+        # Check for at least one uppercase, lowercase, and digit
+        if not re.search(r"[A-Z]", v):
+            raise ValueError("Password must contain at least one uppercase letter")
+        if not re.search(r"[a-z]", v):
+            raise ValueError("Password must contain at least one lowercase letter")
+        if not re.search(r"\d", v):
+            raise ValueError("Password must contain at least one digit")
+
+        return v
+
+    @validator("confirm_password")
+    def validate_confirm_password(cls, v, values):
+        if "password" in values and v != values["password"]:
+            raise ValueError("Passwords do not match")
+        return v
+
+
+class UserLoginRequest(BaseModel):
+    """User login request model"""
+
+    mobile_number: str
+    password: str
+
+    @validator("mobile_number")
+    def validate_mobile_number(cls, v):
+        # Remove all non-digit characters
+        digits_only = re.sub(r"\D", "", v)
+
+        if len(digits_only) < 10 or len(digits_only) > 15:
+            raise ValueError("Invalid mobile number")
+
+        return digits_only
+
+
+@dataclass
+class User:
+    """User model"""
+
+    id: str
+    mobile_number: str
+    full_name: str
+    password_hash: str
+    avatar_url: Optional[str] = None
+    preferences: Optional[str] = None
+    is_active: bool = True
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+
+@dataclass
+class UserSession:
+    """User session model"""
+
+    session_id: str
+    user_id: str
+    mobile_number: str
+    full_name: str
+    created_at: datetime
+    expires_at: datetime
+
+    @property
+    def is_valid(self) -> bool:
+        """Check if session is still valid"""
+        return datetime.utcnow() < self.expires_at
+
+
+class UserAuth:
+    """User authentication utilities"""
+
+    @staticmethod
+    def hash_password(password: str) -> str:
+        """Hash password using SHA-256 with salt"""
+        salt = secrets.token_hex(32)
+        password_hash = hashlib.sha256((password + salt).encode()).hexdigest()
+        return f"{salt}:{password_hash}"
+
+    @staticmethod
+    def verify_password(password: str, password_hash: str) -> bool:
+        """Verify password against stored hash"""
+        try:
+            salt, stored_hash = password_hash.split(":")
+            password_hash_check = hashlib.sha256((password + salt).encode()).hexdigest()
+            return password_hash_check == stored_hash
+        except ValueError:
+            return False
+
+    @staticmethod
+    def generate_session_id() -> str:
+        """Generate secure session ID"""
+        return secrets.token_urlsafe(32)
+
+    @staticmethod
+    def generate_user_id() -> str:
+        """Generate unique user ID"""
+        return f"user_{secrets.token_hex(16)}"
+
+    @staticmethod
+    def format_mobile_number(mobile_number: str) -> str:
+        """Format mobile number for consistent storage"""
+        # Remove all non-digit characters
+        digits_only = re.sub(r"\D", "", mobile_number)
+
+        # Add + prefix if not present and format consistently
+        if not digits_only.startswith("+"):
+            # Assume it's a local number, add default country code if needed
+            if len(digits_only) == 10:  # US format
+                digits_only = f"1{digits_only}"
+
+        return f"+{digits_only}"
+
+    @staticmethod
+    def create_session(user: User, duration_hours: int = 24) -> UserSession:
+        """Create a new user session"""
+        session_id = UserAuth.generate_session_id()
+        created_at = datetime.utcnow()
+        expires_at = created_at + timedelta(hours=duration_hours)
+
+        return UserSession(
+            session_id=session_id,
+            user_id=user.id,
+            mobile_number=user.mobile_number,
+            full_name=user.full_name,
+            created_at=created_at,
+            expires_at=expires_at,
+        )
+
+
+# Response models
+class AuthResponse(BaseModel):
+    """Authentication response model"""
+
+    success: bool
+    message: str
+    session_id: Optional[str] = None
+    user_id: Optional[str] = None
+    full_name: Optional[str] = None
+
+
+class UserProfile(BaseModel):
+    """User profile response model"""
+
+    user_id: str
+    full_name: str
+    mobile_number: str  # Masked for security
+    avatar_url: Optional[str] = None
+    created_at: Optional[str] = None
+
+    @staticmethod
+    def mask_mobile_number(mobile_number: str) -> str:
+        """Mask mobile number for security (show only last 4 digits)"""
+        if len(mobile_number) <= 4:
+            return "*" * len(mobile_number)
+        return "*" * (len(mobile_number) - 4) + mobile_number[-4:]

app/auth_interface.py

@@ -0,0 +1,361 @@
+"""
+Authentication Web Interface for OpenManus
+Mobile number + password based authentication forms
+"""
+
+import asyncio
+import sqlite3
+from typing import Optional, Tuple
+
+import gradio as gr
+
+from app.auth import UserSignupRequest, UserLoginRequest
+from app.auth_service import AuthService
+from app.logger import logger
+
+
+class AuthInterface:
+    """Authentication interface with Gradio"""
+
+    def __init__(self, db_path: str = "openmanus.db"):
+        self.db_path = db_path
+        self.auth_service = None
+        self.current_session = None
+        self.init_database()
+
+    def init_database(self):
+        """Initialize database with schema"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+
+            # Create users table with mobile auth
+            conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS users (
+                    id TEXT PRIMARY KEY,
+                    mobile_number TEXT UNIQUE NOT NULL,
+                    full_name TEXT NOT NULL,
+                    password_hash TEXT NOT NULL,
+                    avatar_url TEXT,
+                    preferences TEXT,
+                    is_active BOOLEAN DEFAULT TRUE,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                )
+            """
+            )
+
+            # Create sessions table
+            conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS sessions (
+                    id TEXT PRIMARY KEY,
+                    user_id TEXT NOT NULL,
+                    title TEXT,
+                    metadata TEXT,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    expires_at DATETIME,
+                    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+                )
+            """
+            )
+
+            conn.commit()
+            conn.close()
+            logger.info("Database initialized successfully")
+
+        except Exception as e:
+            logger.error(f"Database initialization error: {str(e)}")
+
+    def get_db_connection(self):
+        """Get database connection"""
+        return sqlite3.connect(self.db_path)
+
+    async def handle_signup(
+        self, full_name: str, mobile_number: str, password: str, confirm_password: str
+    ) -> Tuple[str, bool, dict]:
+        """Handle user signup"""
+        try:
+            # Validate input
+            if not all([full_name, mobile_number, password, confirm_password]):
+                return "All fields are required", False, gr.update(visible=True)
+
+            # Create signup request
+            signup_data = UserSignupRequest(
+                full_name=full_name,
+                mobile_number=mobile_number,
+                password=password,
+                confirm_password=confirm_password,
+            )
+
+            # Process signup
+            db_conn = self.get_db_connection()
+            auth_service = AuthService(db_conn)
+
+            result = await auth_service.register_user(signup_data)
+            db_conn.close()
+
+            if result.success:
+                self.current_session = {
+                    "session_id": result.session_id,
+                    "user_id": result.user_id,
+                    "full_name": result.full_name,
+                }
+                return (
+                    f"Welcome {result.full_name}! Account created successfully.",
+                    True,
+                    gr.update(visible=False),
+                )
+            else:
+                return result.message, False, gr.update(visible=True)
+
+        except ValueError as e:
+            return str(e), False, gr.update(visible=True)
+        except Exception as e:
+            logger.error(f"Signup error: {str(e)}")
+            return "An error occurred during signup", False, gr.update(visible=True)
+
+    async def handle_login(
+        self, mobile_number: str, password: str
+    ) -> Tuple[str, bool, dict]:
+        """Handle user login"""
+        try:
+            # Validate input
+            if not all([mobile_number, password]):
+                return (
+                    "Mobile number and password are required",
+                    False,
+                    gr.update(visible=True),
+                )
+
+            # Create login request
+            login_data = UserLoginRequest(
+                mobile_number=mobile_number, password=password
+            )
+
+            # Process login
+            db_conn = self.get_db_connection()
+            auth_service = AuthService(db_conn)
+
+            result = await auth_service.login_user(login_data)
+            db_conn.close()
+
+            if result.success:
+                self.current_session = {
+                    "session_id": result.session_id,
+                    "user_id": result.user_id,
+                    "full_name": result.full_name,
+                }
+                return (
+                    f"Welcome back, {result.full_name}!",
+                    True,
+                    gr.update(visible=False),
+                )
+            else:
+                return result.message, False, gr.update(visible=True)
+
+        except ValueError as e:
+            return str(e), False, gr.update(visible=True)
+        except Exception as e:
+            logger.error(f"Login error: {str(e)}")
+            return "An error occurred during login", False, gr.update(visible=True)
+
+    def handle_logout(self) -> Tuple[str, bool, dict]:
+        """Handle user logout"""
+        if self.current_session:
+            # In a real app, you'd delete the session from database
+            self.current_session = None
+
+        return "Logged out successfully", False, gr.update(visible=True)
+
+    def create_interface(self) -> gr.Interface:
+        """Create the authentication interface"""
+
+        with gr.Blocks(
+            title="OpenManus Authentication", theme=gr.themes.Soft()
+        ) as auth_interface:
+            gr.Markdown(
+                """
+            # 🔐 OpenManus Authentication
+            ### Secure Mobile Number + Password Login System
+            """
+            )
+
+            # Session status
+            session_status = gr.Textbox(
+                value="Not logged in", label="Status", interactive=False
+            )
+
+            # Auth forms container
+            with gr.Column(visible=True) as auth_forms:
+
+                with gr.Tabs():
+
+                    # Login Tab
+                    with gr.TabItem("🔑 Login"):
+                        gr.Markdown("### Login with your mobile number and password")
+
+                        login_mobile = gr.Textbox(
+                            label="📱 Mobile Number",
+                            placeholder="Enter your mobile number (e.g., +1234567890)",
+                            lines=1,
+                        )
+
+                        login_password = gr.Textbox(
+                            label="🔒 Password",
+                            type="password",
+                            placeholder="Enter your password",
+                            lines=1,
+                        )
+
+                        login_btn = gr.Button("🔑 Login", variant="primary", size="lg")
+                        login_result = gr.Textbox(label="Result", interactive=False)
+
+                    # Signup Tab
+                    with gr.TabItem("📝 Sign Up"):
+                        gr.Markdown("### Create your new account")
+
+                        signup_fullname = gr.Textbox(
+                            label="👤 Full Name",
+                            placeholder="Enter your full name",
+                            lines=1,
+                        )
+
+                        signup_mobile = gr.Textbox(
+                            label="📱 Mobile Number",
+                            placeholder="Enter your mobile number (e.g., +1234567890)",
+                            lines=1,
+                        )
+
+                        signup_password = gr.Textbox(
+                            label="🔒 Password",
+                            type="password",
+                            placeholder="Create a strong password (min 8 chars, include uppercase, lowercase, digit)",
+                            lines=1,
+                        )
+
+                        signup_confirm_password = gr.Textbox(
+                            label="🔒 Confirm Password",
+                            type="password",
+                            placeholder="Confirm your password",
+                            lines=1,
+                        )
+
+                        signup_btn = gr.Button(
+                            "📝 Create Account", variant="primary", size="lg"
+                        )
+                        signup_result = gr.Textbox(label="Result", interactive=False)
+
+            # Logged in section
+            with gr.Column(visible=False) as logged_in_section:
+                gr.Markdown("### ✅ You are logged in!")
+
+                user_info = gr.Markdown("Welcome!")
+
+                logout_btn = gr.Button("🚪 Logout", variant="secondary")
+                logout_result = gr.Textbox(label="Result", interactive=False)
+
+            # Password requirements info
+            with gr.Accordion("📋 Password Requirements", open=False):
+                gr.Markdown(
+                    """
+                **Password must contain:**
+                - At least 8 characters
+                - At least 1 uppercase letter (A-Z)
+                - At least 1 lowercase letter (a-z)
+                - At least 1 digit (0-9)
+                - Maximum 128 characters
+
+                **Mobile Number Format:**
+                - 10-15 digits
+                - Can include country code
+                - Examples: +1234567890, 1234567890, +91987654321
+                """
+                )
+
+            # Event handlers
+            def sync_signup(*args):
+                """Synchronous wrapper for signup"""
+                return asyncio.run(self.handle_signup(*args))
+
+            def sync_login(*args):
+                """Synchronous wrapper for login"""
+                return asyncio.run(self.handle_login(*args))
+
+            def update_ui_after_auth(result_text, success, auth_forms_update):
+                """Update UI after authentication"""
+                if success:
+                    return (
+                        result_text,  # session_status
+                        auth_forms_update,  # auth_forms visibility
+                        gr.update(visible=True),  # logged_in_section visibility
+                        f"### 👋 {self.current_session['full_name'] if self.current_session else 'User'}",  # user_info
+                    )
+                else:
+                    return (
+                        "Not logged in",  # session_status
+                        auth_forms_update,  # auth_forms visibility
+                        gr.update(visible=False),  # logged_in_section visibility
+                        "Welcome!",  # user_info
+                    )
+
+            def update_ui_after_logout(result_text, success, auth_forms_update):
+                """Update UI after logout"""
+                return (
+                    "Not logged in",  # session_status
+                    auth_forms_update,  # auth_forms visibility
+                    gr.update(visible=False),  # logged_in_section visibility
+                    "Welcome!",  # user_info
+                )
+
+            # Login button click
+            login_btn.click(
+                fn=sync_login,
+                inputs=[login_mobile, login_password],
+                outputs=[login_result, gr.State(), gr.State()],
+            ).then(
+                fn=update_ui_after_auth,
+                inputs=[login_result, gr.State(), gr.State()],
+                outputs=[session_status, auth_forms, logged_in_section, user_info],
+            )
+
+            # Signup button click
+            signup_btn.click(
+                fn=sync_signup,
+                inputs=[
+                    signup_fullname,
+                    signup_mobile,
+                    signup_password,
+                    signup_confirm_password,
+                ],
+                outputs=[signup_result, gr.State(), gr.State()],
+            ).then(
+                fn=update_ui_after_auth,
+                inputs=[signup_result, gr.State(), gr.State()],
+                outputs=[session_status, auth_forms, logged_in_section, user_info],
+            )
+
+            # Logout button click
+            logout_btn.click(
+                fn=self.handle_logout, outputs=[logout_result, gr.State(), gr.State()]
+            ).then(
+                fn=update_ui_after_logout,
+                inputs=[logout_result, gr.State(), gr.State()],
+                outputs=[session_status, auth_forms, logged_in_section, user_info],
+            )
+
+        return auth_interface
+
+
+# Standalone authentication app
+def create_auth_app(db_path: str = "openmanus.db") -> gr.Interface:
+    """Create standalone authentication app"""
+    auth_interface = AuthInterface(db_path)
+    return auth_interface.create_interface()
+
+
+if __name__ == "__main__":
+    # Run standalone auth interface for testing
+    auth_app = create_auth_app()
+    auth_app.launch(server_name="0.0.0.0", server_port=7860, share=False, debug=True)

app/auth_service.py

@@ -0,0 +1,357 @@
+"""
+User authentication service for OpenManus
+Handles user registration, login, and session management with D1 database
+"""
+
+import json
+import sqlite3
+from datetime import datetime
+from typing import Optional, Tuple
+
+from app.auth import (
+    User,
+    UserAuth,
+    UserSession,
+    UserSignupRequest,
+    UserLoginRequest,
+    AuthResponse,
+    UserProfile,
+)
+from app.logger import logger
+
+
+class AuthService:
+    """Authentication service for user management"""
+
+    def __init__(self, db_connection=None):
+        """Initialize auth service with database connection"""
+        self.db = db_connection
+        self.logger = logger
+
+    async def register_user(self, signup_data: UserSignupRequest) -> AuthResponse:
+        """Register a new user"""
+        try:
+            # Format mobile number consistently
+            formatted_mobile = UserAuth.format_mobile_number(signup_data.mobile_number)
+
+            # Check if user already exists
+            existing_user = await self.get_user_by_mobile(formatted_mobile)
+            if existing_user:
+                return AuthResponse(
+                    success=False, message="User with this mobile number already exists"
+                )
+
+            # Create new user
+            user_id = UserAuth.generate_user_id()
+            password_hash = UserAuth.hash_password(signup_data.password)
+
+            user = User(
+                id=user_id,
+                mobile_number=formatted_mobile,
+                full_name=signup_data.full_name,
+                password_hash=password_hash,
+                created_at=datetime.utcnow(),
+                updated_at=datetime.utcnow(),
+            )
+
+            # Save user to database
+            success = await self.save_user(user)
+            if not success:
+                return AuthResponse(
+                    success=False, message="Failed to create user account"
+                )
+
+            # Create session
+            session = UserAuth.create_session(user)
+            session_saved = await self.save_session(session)
+
+            if not session_saved:
+                return AuthResponse(
+                    success=False, message="User created but failed to create session"
+                )
+
+            self.logger.info(f"New user registered: {formatted_mobile}")
+
+            return AuthResponse(
+                success=True,
+                message="Account created successfully",
+                session_id=session.session_id,
+                user_id=user.id,
+                full_name=user.full_name,
+            )
+
+        except Exception as e:
+            self.logger.error(f"User registration error: {str(e)}")
+            return AuthResponse(
+                success=False, message="An error occurred during registration"
+            )
+
+    async def login_user(self, login_data: UserLoginRequest) -> AuthResponse:
+        """Authenticate user login"""
+        try:
+            # Format mobile number consistently
+            formatted_mobile = UserAuth.format_mobile_number(login_data.mobile_number)
+
+            # Get user from database
+            user = await self.get_user_by_mobile(formatted_mobile)
+            if not user:
+                return AuthResponse(
+                    success=False, message="Invalid mobile number or password"
+                )
+
+            # Verify password
+            if not UserAuth.verify_password(login_data.password, user.password_hash):
+                return AuthResponse(
+                    success=False, message="Invalid mobile number or password"
+                )
+
+            # Check if user is active
+            if not user.is_active:
+                return AuthResponse(
+                    success=False,
+                    message="Account is deactivated. Please contact support.",
+                )
+
+            # Create new session
+            session = UserAuth.create_session(user)
+            session_saved = await self.save_session(session)
+
+            if not session_saved:
+                return AuthResponse(
+                    success=False,
+                    message="Login successful but failed to create session",
+                )
+
+            self.logger.info(f"User logged in: {formatted_mobile}")
+
+            return AuthResponse(
+                success=True,
+                message="Login successful",
+                session_id=session.session_id,
+                user_id=user.id,
+                full_name=user.full_name,
+            )
+
+        except Exception as e:
+            self.logger.error(f"User login error: {str(e)}")
+            return AuthResponse(success=False, message="An error occurred during login")
+
+    async def validate_session(self, session_id: str) -> Optional[UserSession]:
+        """Validate user session"""
+        try:
+            if not self.db:
+                return None
+
+            cursor = self.db.cursor()
+            cursor.execute(
+                """
+                SELECT s.id, s.user_id, u.mobile_number, u.full_name,
+                       s.created_at, s.expires_at
+                FROM sessions s
+                JOIN users u ON s.user_id = u.id
+                WHERE s.id = ? AND u.is_active = 1
+            """,
+                (session_id,),
+            )
+
+            row = cursor.fetchone()
+            if not row:
+                return None
+
+            session = UserSession(
+                session_id=row[0],
+                user_id=row[1],
+                mobile_number=row[2],
+                full_name=row[3],
+                created_at=datetime.fromisoformat(row[4]),
+                expires_at=datetime.fromisoformat(row[5]),
+            )
+
+            # Check if session is still valid
+            if not session.is_valid:
+                # Clean up expired session
+                await self.delete_session(session_id)
+                return None
+
+            return session
+
+        except Exception as e:
+            self.logger.error(f"Session validation error: {str(e)}")
+            return None
+
+    async def logout_user(self, session_id: str) -> bool:
+        """Logout user by deleting session"""
+        return await self.delete_session(session_id)
+
+    async def get_user_profile(self, user_id: str) -> Optional[UserProfile]:
+        """Get user profile by user ID"""
+        try:
+            user = await self.get_user_by_id(user_id)
+            if not user:
+                return None
+
+            return UserProfile(
+                user_id=user.id,
+                full_name=user.full_name,
+                mobile_number=UserProfile.mask_mobile_number(user.mobile_number),
+                avatar_url=user.avatar_url,
+                created_at=user.created_at.isoformat() if user.created_at else None,
+            )
+
+        except Exception as e:
+            self.logger.error(f"Get user profile error: {str(e)}")
+            return None
+
+    # Database operations
+    async def save_user(self, user: User) -> bool:
+        """Save user to database"""
+        try:
+            if not self.db:
+                return False
+
+            cursor = self.db.cursor()
+            cursor.execute(
+                """
+                INSERT INTO users (id, mobile_number, full_name, password_hash,
+                                 avatar_url, preferences, is_active, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+                (
+                    user.id,
+                    user.mobile_number,
+                    user.full_name,
+                    user.password_hash,
+                    user.avatar_url,
+                    user.preferences,
+                    user.is_active,
+                    user.created_at.isoformat() if user.created_at else None,
+                    user.updated_at.isoformat() if user.updated_at else None,
+                ),
+            )
+
+            self.db.commit()
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Save user error: {str(e)}")
+            return False
+
+    async def get_user_by_mobile(self, mobile_number: str) -> Optional[User]:
+        """Get user by mobile number"""
+        try:
+            if not self.db:
+                return None
+
+            cursor = self.db.cursor()
+            cursor.execute(
+                """
+                SELECT id, mobile_number, full_name, password_hash, avatar_url,
+                       preferences, is_active, created_at, updated_at
+                FROM users
+                WHERE mobile_number = ?
+            """,
+                (mobile_number,),
+            )
+
+            row = cursor.fetchone()
+            if not row:
+                return None
+
+            return User(
+                id=row[0],
+                mobile_number=row[1],
+                full_name=row[2],
+                password_hash=row[3],
+                avatar_url=row[4],
+                preferences=row[5],
+                is_active=bool(row[6]),
+                created_at=datetime.fromisoformat(row[7]) if row[7] else None,
+                updated_at=datetime.fromisoformat(row[8]) if row[8] else None,
+            )
+
+        except Exception as e:
+            self.logger.error(f"Get user by mobile error: {str(e)}")
+            return None
+
+    async def get_user_by_id(self, user_id: str) -> Optional[User]:
+        """Get user by ID"""
+        try:
+            if not self.db:
+                return None
+
+            cursor = self.db.cursor()
+            cursor.execute(
+                """
+                SELECT id, mobile_number, full_name, password_hash, avatar_url,
+                       preferences, is_active, created_at, updated_at
+                FROM users
+                WHERE id = ? AND is_active = 1
+            """,
+                (user_id,),
+            )
+
+            row = cursor.fetchone()
+            if not row:
+                return None
+
+            return User(
+                id=row[0],
+                mobile_number=row[1],
+                full_name=row[2],
+                password_hash=row[3],
+                avatar_url=row[4],
+                preferences=row[5],
+                is_active=bool(row[6]),
+                created_at=datetime.fromisoformat(row[7]) if row[7] else None,
+                updated_at=datetime.fromisoformat(row[8]) if row[8] else None,
+            )
+
+        except Exception as e:
+            self.logger.error(f"Get user by ID error: {str(e)}")
+            return None
+
+    async def save_session(self, session: UserSession) -> bool:
+        """Save session to database"""
+        try:
+            if not self.db:
+                return False
+
+            cursor = self.db.cursor()
+            cursor.execute(
+                """
+                INSERT INTO sessions (id, user_id, title, metadata, created_at,
+                                    updated_at, expires_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+                (
+                    session.session_id,
+                    session.user_id,
+                    "User Session",
+                    json.dumps({"login_type": "mobile_password"}),
+                    session.created_at.isoformat(),
+                    session.created_at.isoformat(),
+                    session.expires_at.isoformat(),
+                ),
+            )
+
+            self.db.commit()
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Save session error: {str(e)}")
+            return False
+
+    async def delete_session(self, session_id: str) -> bool:
+        """Delete session from database"""
+        try:
+            if not self.db:
+                return False
+
+            cursor = self.db.cursor()
+            cursor.execute("DELETE FROM sessions WHERE id = ?", (session_id,))
+            self.db.commit()
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Delete session error: {str(e)}")
+            return False

app/cloudflare/__init__.py

@@ -0,0 +1,11 @@
+"""
+Cloudflare services integration for OpenManus
+"""
+
+from .client import CloudflareClient
+from .d1 import D1Database
+from .durable_objects import DurableObjects
+from .kv import KVStorage
+from .r2 import R2Storage
+
+__all__ = ["CloudflareClient", "D1Database", "R2Storage", "KVStorage", "DurableObjects"]

app/cloudflare/client.py

@@ -0,0 +1,228 @@
+"""
+Cloudflare API Client
+Handles authentication and base HTTP operations for Cloudflare services
+"""
+
+import asyncio
+import json
+from typing import Any, Dict, Optional, Union
+
+import aiohttp
+
+from app.logger import logger
+
+
+class CloudflareClient:
+    """Base client for Cloudflare API operations"""
+
+    def __init__(
+        self,
+        api_token: str,
+        account_id: str,
+        worker_url: Optional[str] = None,
+        timeout: int = 30,
+    ):
+        self.api_token = api_token
+        self.account_id = account_id
+        self.worker_url = worker_url
+        self.timeout = timeout
+        self.base_url = "https://api.cloudflare.com/client/v4"
+
+        # HTTP headers for API requests
+        self.headers = {
+            "Authorization": f"Bearer {api_token}",
+            "Content-Type": "application/json",
+        }
+
+    async def _make_request(
+        self,
+        method: str,
+        url: str,
+        data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        use_worker: bool = False,
+    ) -> Dict[str, Any]:
+        """Make HTTP request to Cloudflare API or Worker"""
+
+        # Use worker URL if specified and use_worker is True
+        if use_worker and self.worker_url:
+            full_url = f"{self.worker_url.rstrip('/')}/{url.lstrip('/')}"
+        else:
+            full_url = f"{self.base_url}/{url.lstrip('/')}"
+
+        request_headers = self.headers.copy()
+        if headers:
+            request_headers.update(headers)
+
+        timeout = aiohttp.ClientTimeout(total=self.timeout)
+
+        try:
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.request(
+                    method=method.upper(),
+                    url=full_url,
+                    headers=request_headers,
+                    json=data if data else None,
+                ) as response:
+                    response_text = await response.text()
+
+                    try:
+                        response_data = (
+                            json.loads(response_text) if response_text else {}
+                        )
+                    except json.JSONDecodeError:
+                        response_data = {"raw_response": response_text}
+
+                    if not response.ok:
+                        logger.error(
+                            f"Cloudflare API error: {response.status} - {response_text}"
+                        )
+                        raise CloudflareError(
+                            f"HTTP {response.status}: {response_text}",
+                            response.status,
+                            response_data,
+                        )
+
+                    return response_data
+
+        except asyncio.TimeoutError:
+            logger.error(f"Timeout making request to {full_url}")
+            raise CloudflareError(f"Request timeout after {self.timeout}s")
+        except aiohttp.ClientError as e:
+            logger.error(f"HTTP client error: {e}")
+            raise CloudflareError(f"Client error: {e}")
+
+    async def get(
+        self,
+        url: str,
+        headers: Optional[Dict[str, str]] = None,
+        use_worker: bool = False,
+    ) -> Dict[str, Any]:
+        """Make GET request"""
+        return await self._make_request(
+            "GET", url, headers=headers, use_worker=use_worker
+        )
+
+    async def post(
+        self,
+        url: str,
+        data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        use_worker: bool = False,
+    ) -> Dict[str, Any]:
+        """Make POST request"""
+        return await self._make_request(
+            "POST", url, data=data, headers=headers, use_worker=use_worker
+        )
+
+    async def put(
+        self,
+        url: str,
+        data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        use_worker: bool = False,
+    ) -> Dict[str, Any]:
+        """Make PUT request"""
+        return await self._make_request(
+            "PUT", url, data=data, headers=headers, use_worker=use_worker
+        )
+
+    async def delete(
+        self,
+        url: str,
+        headers: Optional[Dict[str, str]] = None,
+        use_worker: bool = False,
+    ) -> Dict[str, Any]:
+        """Make DELETE request"""
+        return await self._make_request(
+            "DELETE", url, headers=headers, use_worker=use_worker
+        )
+
+    async def upload_file(
+        self,
+        url: str,
+        file_data: bytes,
+        content_type: str = "application/octet-stream",
+        headers: Optional[Dict[str, str]] = None,
+        use_worker: bool = False,
+    ) -> Dict[str, Any]:
+        """Upload file data"""
+
+        # Use worker URL if specified and use_worker is True
+        if use_worker and self.worker_url:
+            full_url = f"{self.worker_url.rstrip('/')}/{url.lstrip('/')}"
+        else:
+            full_url = f"{self.base_url}/{url.lstrip('/')}"
+
+        upload_headers = {
+            "Authorization": f"Bearer {self.api_token}",
+            "Content-Type": content_type,
+        }
+        if headers:
+            upload_headers.update(headers)
+
+        timeout = aiohttp.ClientTimeout(
+            total=self.timeout * 2
+        )  # Longer timeout for uploads
+
+        try:
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.put(
+                    url=full_url, headers=upload_headers, data=file_data
+                ) as response:
+                    response_text = await response.text()
+
+                    try:
+                        response_data = (
+                            json.loads(response_text) if response_text else {}
+                        )
+                    except json.JSONDecodeError:
+                        response_data = {"raw_response": response_text}
+
+                    if not response.ok:
+                        logger.error(
+                            f"File upload error: {response.status} - {response_text}"
+                        )
+                        raise CloudflareError(
+                            f"Upload failed: HTTP {response.status}",
+                            response.status,
+                            response_data,
+                        )
+
+                    return response_data
+
+        except asyncio.TimeoutError:
+            logger.error(f"Timeout uploading file to {full_url}")
+            raise CloudflareError(f"Upload timeout after {self.timeout * 2}s")
+        except aiohttp.ClientError as e:
+            logger.error(f"Upload client error: {e}")
+            raise CloudflareError(f"Upload error: {e}")
+
+    def get_account_url(self, endpoint: str) -> str:
+        """Get URL for account-scoped endpoint"""
+        return f"accounts/{self.account_id}/{endpoint}"
+
+    def get_worker_url(self, endpoint: str) -> str:
+        """Get URL for worker endpoint"""
+        if not self.worker_url:
+            raise CloudflareError("Worker URL not configured")
+        return endpoint
+
+
+class CloudflareError(Exception):
+    """Cloudflare API error"""
+
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        response_data: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response_data = response_data or {}
+
+    def __str__(self) -> str:
+        if self.status_code:
+            return f"CloudflareError({self.status_code}): {super().__str__()}"
+        return f"CloudflareError: {super().__str__()}"

app/cloudflare/d1.py

@@ -0,0 +1,510 @@
+"""
+D1 Database integration for OpenManus
+Provides interface to Cloudflare D1 database operations
+"""
+
+from typing import Any, Dict, List, Optional, Union
+
+from app.logger import logger
+
+from .client import CloudflareClient, CloudflareError
+
+
+class D1Database:
+    """Cloudflare D1 Database client"""
+
+    def __init__(self, client: CloudflareClient, database_id: str):
+        self.client = client
+        self.database_id = database_id
+        self.base_endpoint = f"accounts/{client.account_id}/d1/database/{database_id}"
+
+    async def execute_query(
+        self, sql: str, params: Optional[List[Any]] = None, use_worker: bool = True
+    ) -> Dict[str, Any]:
+        """Execute a SQL query"""
+
+        query_data = {"sql": sql}
+
+        if params:
+            query_data["params"] = params
+
+        try:
+            if use_worker:
+                # Use worker endpoint for better performance
+                response = await self.client.post(
+                    "api/database/query", data=query_data, use_worker=True
+                )
+            else:
+                # Use Cloudflare API directly
+                response = await self.client.post(
+                    f"{self.base_endpoint}/query", data=query_data
+                )
+
+            return response
+
+        except CloudflareError as e:
+            logger.error(f"D1 query execution failed: {e}")
+            raise
+
+    async def batch_execute(
+        self, queries: List[Dict[str, Any]], use_worker: bool = True
+    ) -> Dict[str, Any]:
+        """Execute multiple queries in a batch"""
+
+        batch_data = {"queries": queries}
+
+        try:
+            if use_worker:
+                response = await self.client.post(
+                    "api/database/batch", data=batch_data, use_worker=True
+                )
+            else:
+                response = await self.client.post(
+                    f"{self.base_endpoint}/query", data=batch_data
+                )
+
+            return response
+
+        except CloudflareError as e:
+            logger.error(f"D1 batch execution failed: {e}")
+            raise
+
+    # User management methods
+    async def create_user(
+        self,
+        user_id: str,
+        username: str,
+        email: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Create a new user"""
+
+        sql = """
+        INSERT INTO users (id, username, email, metadata)
+        VALUES (?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+        username = excluded.username,
+        email = excluded.email,
+        metadata = excluded.metadata,
+        updated_at = strftime('%s', 'now')
+        """
+
+        import json
+
+        params = [user_id, username, email, json.dumps(metadata or {})]
+
+        return await self.execute_query(sql, params)
+
+    async def get_user(self, user_id: str) -> Optional[Dict[str, Any]]:
+        """Get user by ID"""
+
+        sql = "SELECT * FROM users WHERE id = ?"
+        params = [user_id]
+
+        result = await self.execute_query(sql, params)
+
+        # Parse response based on Cloudflare D1 format
+        if result.get("success") and result.get("result"):
+            rows = result["result"][0].get("results", [])
+            if rows:
+                user = rows[0]
+                if user.get("metadata"):
+                    import json
+
+                    user["metadata"] = json.loads(user["metadata"])
+                return user
+
+        return None
+
+    async def get_user_by_username(self, username: str) -> Optional[Dict[str, Any]]:
+        """Get user by username"""
+
+        sql = "SELECT * FROM users WHERE username = ?"
+        params = [username]
+
+        result = await self.execute_query(sql, params)
+
+        if result.get("success") and result.get("result"):
+            rows = result["result"][0].get("results", [])
+            if rows:
+                user = rows[0]
+                if user.get("metadata"):
+                    import json
+
+                    user["metadata"] = json.loads(user["metadata"])
+                return user
+
+        return None
+
+    # Session management methods
+    async def create_session(
+        self,
+        session_id: str,
+        user_id: str,
+        session_data: Dict[str, Any],
+        expires_at: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Create a new session"""
+
+        sql = """
+        INSERT INTO sessions (id, user_id, session_data, expires_at)
+        VALUES (?, ?, ?, ?)
+        """
+
+        import json
+
+        params = [session_id, user_id, json.dumps(session_data), expires_at]
+
+        return await self.execute_query(sql, params)
+
+    async def get_session(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """Get session by ID"""
+
+        sql = """
+        SELECT * FROM sessions
+        WHERE id = ? AND (expires_at IS NULL OR expires_at > strftime('%s', 'now'))
+        """
+        params = [session_id]
+
+        result = await self.execute_query(sql, params)
+
+        if result.get("success") and result.get("result"):
+            rows = result["result"][0].get("results", [])
+            if rows:
+                session = rows[0]
+                if session.get("session_data"):
+                    import json
+
+                    session["session_data"] = json.loads(session["session_data"])
+                return session
+
+        return None
+
+    async def delete_session(self, session_id: str) -> Dict[str, Any]:
+        """Delete a session"""
+
+        sql = "DELETE FROM sessions WHERE id = ?"
+        params = [session_id]
+
+        return await self.execute_query(sql, params)
+
+    # Conversation methods
+    async def create_conversation(
+        self,
+        conversation_id: str,
+        user_id: str,
+        title: Optional[str] = None,
+        messages: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        """Create a new conversation"""
+
+        sql = """
+        INSERT INTO conversations (id, user_id, title, messages)
+        VALUES (?, ?, ?, ?)
+        """
+
+        import json
+
+        params = [conversation_id, user_id, title, json.dumps(messages or [])]
+
+        return await self.execute_query(sql, params)
+
+    async def get_conversation(self, conversation_id: str) -> Optional[Dict[str, Any]]:
+        """Get conversation by ID"""
+
+        sql = "SELECT * FROM conversations WHERE id = ?"
+        params = [conversation_id]
+
+        result = await self.execute_query(sql, params)
+
+        if result.get("success") and result.get("result"):
+            rows = result["result"][0].get("results", [])
+            if rows:
+                conversation = rows[0]
+                if conversation.get("messages"):
+                    import json
+
+                    conversation["messages"] = json.loads(conversation["messages"])
+                return conversation
+
+        return None
+
+    async def update_conversation_messages(
+        self, conversation_id: str, messages: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """Update conversation messages"""
+
+        sql = """
+        UPDATE conversations
+        SET messages = ?, updated_at = strftime('%s', 'now')
+        WHERE id = ?
+        """
+
+        import json
+
+        params = [json.dumps(messages), conversation_id]
+
+        return await self.execute_query(sql, params)
+
+    async def get_user_conversations(
+        self, user_id: str, limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        """Get user's conversations"""
+
+        sql = """
+        SELECT id, user_id, title, created_at, updated_at
+        FROM conversations
+        WHERE user_id = ?
+        ORDER BY updated_at DESC
+        LIMIT ?
+        """
+        params = [user_id, limit]
+
+        result = await self.execute_query(sql, params)
+
+        if result.get("success") and result.get("result"):
+            return result["result"][0].get("results", [])
+
+        return []
+
+    # Agent execution methods
+    async def create_agent_execution(
+        self,
+        execution_id: str,
+        user_id: str,
+        session_id: Optional[str] = None,
+        task_description: Optional[str] = None,
+        status: str = "pending",
+    ) -> Dict[str, Any]:
+        """Create a new agent execution record"""
+
+        sql = """
+        INSERT INTO agent_executions (id, user_id, session_id, task_description, status)
+        VALUES (?, ?, ?, ?, ?)
+        """
+
+        params = [execution_id, user_id, session_id, task_description, status]
+
+        return await self.execute_query(sql, params)
+
+    async def update_agent_execution(
+        self,
+        execution_id: str,
+        status: Optional[str] = None,
+        result: Optional[str] = None,
+        execution_time: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Update agent execution record"""
+
+        updates = []
+        params = []
+
+        if status:
+            updates.append("status = ?")
+            params.append(status)
+
+        if result:
+            updates.append("result = ?")
+            params.append(result)
+
+        if execution_time is not None:
+            updates.append("execution_time = ?")
+            params.append(execution_time)
+
+        if status in ["completed", "failed"]:
+            updates.append("completed_at = strftime('%s', 'now')")
+
+        if not updates:
+            return {"success": True, "message": "No updates provided"}
+
+        sql = f"""
+        UPDATE agent_executions
+        SET {', '.join(updates)}
+        WHERE id = ?
+        """
+        params.append(execution_id)
+
+        return await self.execute_query(sql, params)
+
+    async def get_agent_execution(self, execution_id: str) -> Optional[Dict[str, Any]]:
+        """Get agent execution by ID"""
+
+        sql = "SELECT * FROM agent_executions WHERE id = ?"
+        params = [execution_id]
+
+        result = await self.execute_query(sql, params)
+
+        if result.get("success") and result.get("result"):
+            rows = result["result"][0].get("results", [])
+            if rows:
+                return rows[0]
+
+        return None
+
+    async def get_user_executions(
+        self, user_id: str, limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        """Get user's agent executions"""
+
+        sql = """
+        SELECT * FROM agent_executions
+        WHERE user_id = ?
+        ORDER BY created_at DESC
+        LIMIT ?
+        """
+        params = [user_id, limit]
+
+        result = await self.execute_query(sql, params)
+
+        if result.get("success") and result.get("result"):
+            return result["result"][0].get("results", [])
+
+        return []
+
+    # File record methods
+    async def create_file_record(
+        self,
+        file_id: str,
+        user_id: str,
+        filename: str,
+        file_key: str,
+        file_size: int,
+        content_type: str,
+        bucket: str = "storage",
+    ) -> Dict[str, Any]:
+        """Create a file record"""
+
+        sql = """
+        INSERT INTO files (id, user_id, filename, file_key, file_size, content_type, bucket)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+        """
+
+        params = [file_id, user_id, filename, file_key, file_size, content_type, bucket]
+
+        return await self.execute_query(sql, params)
+
+    async def get_file_record(self, file_id: str) -> Optional[Dict[str, Any]]:
+        """Get file record by ID"""
+
+        sql = "SELECT * FROM files WHERE id = ?"
+        params = [file_id]
+
+        result = await self.execute_query(sql, params)
+
+        if result.get("success") and result.get("result"):
+            rows = result["result"][0].get("results", [])
+            if rows:
+                return rows[0]
+
+        return None
+
+    async def get_user_files(
+        self, user_id: str, limit: int = 100
+    ) -> List[Dict[str, Any]]:
+        """Get user's files"""
+
+        sql = """
+        SELECT * FROM files
+        WHERE user_id = ?
+        ORDER BY created_at DESC
+        LIMIT ?
+        """
+        params = [user_id, limit]
+
+        result = await self.execute_query(sql, params)
+
+        if result.get("success") and result.get("result"):
+            return result["result"][0].get("results", [])
+
+        return []
+
+    async def delete_file_record(self, file_id: str) -> Dict[str, Any]:
+        """Delete a file record"""
+
+        sql = "DELETE FROM files WHERE id = ?"
+        params = [file_id]
+
+        return await self.execute_query(sql, params)
+
+    # Schema initialization
+    async def initialize_schema(self) -> Dict[str, Any]:
+        """Initialize database schema"""
+
+        schema_queries = [
+            {
+                "sql": """CREATE TABLE IF NOT EXISTS users (
+                    id TEXT PRIMARY KEY,
+                    username TEXT UNIQUE NOT NULL,
+                    email TEXT UNIQUE,
+                    created_at INTEGER DEFAULT (strftime('%s', 'now')),
+                    updated_at INTEGER DEFAULT (strftime('%s', 'now')),
+                    metadata TEXT
+                )"""
+            },
+            {
+                "sql": """CREATE TABLE IF NOT EXISTS sessions (
+                    id TEXT PRIMARY KEY,
+                    user_id TEXT NOT NULL,
+                    session_data TEXT,
+                    created_at INTEGER DEFAULT (strftime('%s', 'now')),
+                    expires_at INTEGER,
+                    FOREIGN KEY (user_id) REFERENCES users(id)
+                )"""
+            },
+            {
+                "sql": """CREATE TABLE IF NOT EXISTS conversations (
+                    id TEXT PRIMARY KEY,
+                    user_id TEXT NOT NULL,
+                    title TEXT,
+                    messages TEXT,
+                    created_at INTEGER DEFAULT (strftime('%s', 'now')),
+                    updated_at INTEGER DEFAULT (strftime('%s', 'now')),
+                    FOREIGN KEY (user_id) REFERENCES users(id)
+                )"""
+            },
+            {
+                "sql": """CREATE TABLE IF NOT EXISTS files (
+                    id TEXT PRIMARY KEY,
+                    user_id TEXT NOT NULL,
+                    filename TEXT NOT NULL,
+                    file_key TEXT NOT NULL,
+                    file_size INTEGER,
+                    content_type TEXT,
+                    bucket TEXT DEFAULT 'storage',
+                    created_at INTEGER DEFAULT (strftime('%s', 'now')),
+                    FOREIGN KEY (user_id) REFERENCES users(id)
+                )"""
+            },
+            {
+                "sql": """CREATE TABLE IF NOT EXISTS agent_executions (
+                    id TEXT PRIMARY KEY,
+                    user_id TEXT NOT NULL,
+                    session_id TEXT,
+                    task_description TEXT,
+                    status TEXT DEFAULT 'pending',
+                    result TEXT,
+                    execution_time INTEGER,
+                    created_at INTEGER DEFAULT (strftime('%s', 'now')),
+                    completed_at INTEGER,
+                    FOREIGN KEY (user_id) REFERENCES users(id)
+                )"""
+            },
+        ]
+
+        # Add indexes
+        index_queries = [
+            {
+                "sql": "CREATE INDEX IF NOT EXISTS idx_sessions_user_id ON sessions(user_id)"
+            },
+            {
+                "sql": "CREATE INDEX IF NOT EXISTS idx_conversations_user_id ON conversations(user_id)"
+            },
+            {"sql": "CREATE INDEX IF NOT EXISTS idx_files_user_id ON files(user_id)"},
+            {
+                "sql": "CREATE INDEX IF NOT EXISTS idx_agent_executions_user_id ON agent_executions(user_id)"
+            },
+        ]
+
+        all_queries = schema_queries + index_queries
+
+        return await self.batch_execute(all_queries)

app/cloudflare/durable_objects.py

@@ -0,0 +1,365 @@
+"""
+Durable Objects integration for OpenManus
+Provides interface to Cloudflare Durable Objects operations
+"""
+
+import json
+import time
+from typing import Any, Dict, List, Optional
+
+from app.logger import logger
+
+from .client import CloudflareClient, CloudflareError
+
+
+class DurableObjects:
+    """Cloudflare Durable Objects client"""
+
+    def __init__(self, client: CloudflareClient):
+        self.client = client
+
+    async def create_agent_session(
+        self, session_id: str, user_id: str, metadata: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Create a new agent session"""
+
+        session_data = {
+            "sessionId": session_id,
+            "userId": user_id,
+            "metadata": metadata or {},
+        }
+
+        try:
+            response = await self.client.post(
+                f"do/agent/{session_id}/start", data=session_data, use_worker=True
+            )
+
+            return {
+                "success": True,
+                "session_id": session_id,
+                "user_id": user_id,
+                **response,
+            }
+
+        except CloudflareError as e:
+            logger.error(f"Failed to create agent session: {e}")
+            raise
+
+    async def get_agent_session_status(self, session_id: str) -> Dict[str, Any]:
+        """Get agent session status"""
+
+        try:
+            response = await self.client.get(
+                f"do/agent/{session_id}/status?sessionId={session_id}", use_worker=True
+            )
+
+            return response
+
+        except CloudflareError as e:
+            logger.error(f"Failed to get agent session status: {e}")
+            raise
+
+    async def update_agent_session(
+        self, session_id: str, updates: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Update agent session"""
+
+        update_data = {"sessionId": session_id, "updates": updates}
+
+        try:
+            response = await self.client.post(
+                f"do/agent/{session_id}/update", data=update_data, use_worker=True
+            )
+
+            return {"success": True, "session_id": session_id, **response}
+
+        except CloudflareError as e:
+            logger.error(f"Failed to update agent session: {e}")
+            raise
+
+    async def stop_agent_session(self, session_id: str) -> Dict[str, Any]:
+        """Stop agent session"""
+
+        try:
+            response = await self.client.post(
+                f"do/agent/{session_id}/stop",
+                data={"sessionId": session_id},
+                use_worker=True,
+            )
+
+            return {"success": True, "session_id": session_id, **response}
+
+        except CloudflareError as e:
+            logger.error(f"Failed to stop agent session: {e}")
+            raise
+
+    async def add_agent_message(
+        self, session_id: str, message: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Add a message to agent session"""
+
+        message_data = {
+            "sessionId": session_id,
+            "message": {"timestamp": int(time.time()), **message},
+        }
+
+        try:
+            response = await self.client.post(
+                f"do/agent/{session_id}/messages", data=message_data, use_worker=True
+            )
+
+            return {"success": True, "session_id": session_id, **response}
+
+        except CloudflareError as e:
+            logger.error(f"Failed to add agent message: {e}")
+            raise
+
+    async def get_agent_messages(
+        self, session_id: str, limit: int = 50, offset: int = 0
+    ) -> Dict[str, Any]:
+        """Get agent session messages"""
+
+        try:
+            response = await self.client.get(
+                f"do/agent/{session_id}/messages?sessionId={session_id}&limit={limit}&offset={offset}",
+                use_worker=True,
+            )
+
+            return response
+
+        except CloudflareError as e:
+            logger.error(f"Failed to get agent messages: {e}")
+            raise
+
+    # Chat Room methods
+    async def join_chat_room(
+        self,
+        room_id: str,
+        user_id: str,
+        username: str,
+        room_config: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Join a chat room"""
+
+        join_data = {
+            "userId": user_id,
+            "username": username,
+            "roomConfig": room_config or {},
+        }
+
+        try:
+            response = await self.client.post(
+                f"do/chat/{room_id}/join", data=join_data, use_worker=True
+            )
+
+            return {"success": True, "room_id": room_id, "user_id": user_id, **response}
+
+        except CloudflareError as e:
+            logger.error(f"Failed to join chat room: {e}")
+            raise
+
+    async def leave_chat_room(self, room_id: str, user_id: str) -> Dict[str, Any]:
+        """Leave a chat room"""
+
+        leave_data = {"userId": user_id}
+
+        try:
+            response = await self.client.post(
+                f"do/chat/{room_id}/leave", data=leave_data, use_worker=True
+            )
+
+            return {"success": True, "room_id": room_id, "user_id": user_id, **response}
+
+        except CloudflareError as e:
+            logger.error(f"Failed to leave chat room: {e}")
+            raise
+
+    async def get_chat_room_info(self, room_id: str) -> Dict[str, Any]:
+        """Get chat room information"""
+
+        try:
+            response = await self.client.get(f"do/chat/{room_id}/info", use_worker=True)
+
+            return response
+
+        except CloudflareError as e:
+            logger.error(f"Failed to get chat room info: {e}")
+            raise
+
+    async def send_chat_message(
+        self,
+        room_id: str,
+        user_id: str,
+        username: str,
+        content: str,
+        message_type: str = "text",
+    ) -> Dict[str, Any]:
+        """Send a message to chat room"""
+
+        message_data = {
+            "userId": user_id,
+            "username": username,
+            "content": content,
+            "messageType": message_type,
+        }
+
+        try:
+            response = await self.client.post(
+                f"do/chat/{room_id}/messages", data=message_data, use_worker=True
+            )
+
+            return {"success": True, "room_id": room_id, **response}
+
+        except CloudflareError as e:
+            logger.error(f"Failed to send chat message: {e}")
+            raise
+
+    async def get_chat_messages(
+        self, room_id: str, limit: int = 50, offset: int = 0
+    ) -> Dict[str, Any]:
+        """Get chat room messages"""
+
+        try:
+            response = await self.client.get(
+                f"do/chat/{room_id}/messages?limit={limit}&offset={offset}",
+                use_worker=True,
+            )
+
+            return response
+
+        except CloudflareError as e:
+            logger.error(f"Failed to get chat messages: {e}")
+            raise
+
+    async def get_chat_participants(self, room_id: str) -> Dict[str, Any]:
+        """Get chat room participants"""
+
+        try:
+            response = await self.client.get(
+                f"do/chat/{room_id}/participants", use_worker=True
+            )
+
+            return response
+
+        except CloudflareError as e:
+            logger.error(f"Failed to get chat participants: {e}")
+            raise
+
+    # WebSocket connection helpers
+    def get_agent_websocket_url(self, session_id: str, user_id: str) -> str:
+        """Get WebSocket URL for agent session"""
+
+        if not self.client.worker_url:
+            raise CloudflareError("Worker URL not configured")
+
+        base_url = self.client.worker_url.replace("https://", "wss://").replace(
+            "http://", "ws://"
+        )
+        return (
+            f"{base_url}/do/agent/{session_id}?sessionId={session_id}&userId={user_id}"
+        )
+
+    def get_chat_websocket_url(self, room_id: str, user_id: str, username: str) -> str:
+        """Get WebSocket URL for chat room"""
+
+        if not self.client.worker_url:
+            raise CloudflareError("Worker URL not configured")
+
+        base_url = self.client.worker_url.replace("https://", "wss://").replace(
+            "http://", "ws://"
+        )
+        return f"{base_url}/do/chat/{room_id}?userId={user_id}&username={username}"
+
+
+class DurableObjectsWebSocket:
+    """Helper class for WebSocket connections to Durable Objects"""
+
+    def __init__(self, url: str):
+        self.url = url
+        self.websocket = None
+        self.connected = False
+        self.message_handlers = {}
+
+    async def connect(self):
+        """Connect to WebSocket"""
+        try:
+            import websockets
+
+            self.websocket = await websockets.connect(self.url)
+            self.connected = True
+            logger.info(f"Connected to Durable Object WebSocket: {self.url}")
+
+            # Start message handling loop
+            import asyncio
+
+            asyncio.create_task(self._message_loop())
+
+        except Exception as e:
+            logger.error(f"Failed to connect to WebSocket: {e}")
+            raise CloudflareError(f"WebSocket connection failed: {e}")
+
+    async def disconnect(self):
+        """Disconnect from WebSocket"""
+        if self.websocket and self.connected:
+            await self.websocket.close()
+            self.connected = False
+            logger.info("Disconnected from Durable Object WebSocket")
+
+    async def send_message(self, message_type: str, payload: Dict[str, Any]):
+        """Send message via WebSocket"""
+        if not self.connected or not self.websocket:
+            raise CloudflareError("WebSocket not connected")
+
+        message = {
+            "type": message_type,
+            "payload": payload,
+            "timestamp": int(time.time()),
+        }
+
+        try:
+            await self.websocket.send(json.dumps(message))
+        except Exception as e:
+            logger.error(f"Failed to send WebSocket message: {e}")
+            raise CloudflareError(f"Failed to send message: {e}")
+
+    def add_message_handler(self, message_type: str, handler):
+        """Add a message handler for specific message types"""
+        if message_type not in self.message_handlers:
+            self.message_handlers[message_type] = []
+        self.message_handlers[message_type].append(handler)
+
+    async def _message_loop(self):
+        """Handle incoming WebSocket messages"""
+        try:
+            async for message in self.websocket:
+                try:
+                    data = json.loads(message)
+                    message_type = data.get("type")
+
+                    if message_type in self.message_handlers:
+                        for handler in self.message_handlers[message_type]:
+                            try:
+                                if callable(handler):
+                                    if asyncio.iscoroutinefunction(handler):
+                                        await handler(data)
+                                    else:
+                                        handler(data)
+                            except Exception as e:
+                                logger.error(f"Message handler error: {e}")
+
+                except json.JSONDecodeError as e:
+                    logger.error(f"Failed to parse WebSocket message: {e}")
+                except Exception as e:
+                    logger.error(f"WebSocket message processing error: {e}")
+
+        except Exception as e:
+            logger.error(f"WebSocket message loop error: {e}")
+            self.connected = False
+
+    # Context manager support
+    async def __aenter__(self):
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.disconnect()

app/cloudflare/kv.py

@@ -0,0 +1,457 @@
+"""
+KV Storage integration for OpenManus
+Provides interface to Cloudflare KV operations
+"""
+
+import json
+from typing import Any, Dict, List, Optional
+
+from app.logger import logger
+
+from .client import CloudflareClient, CloudflareError
+
+
+class KVStorage:
+    """Cloudflare KV Storage client"""
+
+    def __init__(
+        self,
+        client: CloudflareClient,
+        sessions_namespace_id: str,
+        cache_namespace_id: str,
+    ):
+        self.client = client
+        self.sessions_namespace_id = sessions_namespace_id
+        self.cache_namespace_id = cache_namespace_id
+        self.base_endpoint = f"accounts/{client.account_id}/storage/kv/namespaces"
+
+    def _get_namespace_id(self, namespace_type: str) -> str:
+        """Get namespace ID based on type"""
+        if namespace_type == "cache":
+            return self.cache_namespace_id
+        return self.sessions_namespace_id
+
+    async def set_value(
+        self,
+        key: str,
+        value: Any,
+        namespace_type: str = "sessions",
+        ttl: Optional[int] = None,
+        use_worker: bool = True,
+    ) -> Dict[str, Any]:
+        """Set a value in KV store"""
+
+        namespace_id = self._get_namespace_id(namespace_type)
+
+        # Serialize value to JSON
+        if isinstance(value, (dict, list)):
+            serialized_value = json.dumps(value)
+        elif isinstance(value, str):
+            serialized_value = value
+        else:
+            serialized_value = json.dumps(value)
+
+        try:
+            if use_worker:
+                set_data = {
+                    "key": key,
+                    "value": serialized_value,
+                    "namespace": namespace_type,
+                }
+
+                if ttl:
+                    set_data["ttl"] = ttl
+
+                response = await self.client.post(
+                    f"api/kv/set", data=set_data, use_worker=True
+                )
+            else:
+                # Use KV API directly
+                params = {}
+                if ttl:
+                    params["expiration_ttl"] = ttl
+
+                query_string = "&".join([f"{k}={v}" for k, v in params.items()])
+                endpoint = f"{self.base_endpoint}/{namespace_id}/values/{key}"
+                if query_string:
+                    endpoint += f"?{query_string}"
+
+                response = await self.client.put(
+                    endpoint, data={"value": serialized_value}
+                )
+
+            return {
+                "success": True,
+                "key": key,
+                "namespace": namespace_type,
+                "ttl": ttl,
+                **response,
+            }
+
+        except CloudflareError as e:
+            logger.error(f"KV set value failed: {e}")
+            raise
+
+    async def get_value(
+        self,
+        key: str,
+        namespace_type: str = "sessions",
+        parse_json: bool = True,
+        use_worker: bool = True,
+    ) -> Optional[Any]:
+        """Get a value from KV store"""
+
+        namespace_id = self._get_namespace_id(namespace_type)
+
+        try:
+            if use_worker:
+                response = await self.client.get(
+                    f"api/kv/get/{key}?namespace={namespace_type}", use_worker=True
+                )
+
+                if response and "value" in response:
+                    value = response["value"]
+
+                    if parse_json and isinstance(value, str):
+                        try:
+                            return json.loads(value)
+                        except json.JSONDecodeError:
+                            return value
+
+                    return value
+            else:
+                response = await self.client.get(
+                    f"{self.base_endpoint}/{namespace_id}/values/{key}"
+                )
+
+                # KV API returns the value directly as text
+                value = (
+                    response.get("result", {}).get("value")
+                    if "result" in response
+                    else response
+                )
+
+                if value and parse_json and isinstance(value, str):
+                    try:
+                        return json.loads(value)
+                    except json.JSONDecodeError:
+                        return value
+
+                return value
+
+        except CloudflareError as e:
+            if e.status_code == 404:
+                return None
+            logger.error(f"KV get value failed: {e}")
+            raise
+
+        return None
+
+    async def delete_value(
+        self, key: str, namespace_type: str = "sessions", use_worker: bool = True
+    ) -> Dict[str, Any]:
+        """Delete a value from KV store"""
+
+        namespace_id = self._get_namespace_id(namespace_type)
+
+        try:
+            if use_worker:
+                response = await self.client.delete(
+                    f"api/kv/delete/{key}?namespace={namespace_type}", use_worker=True
+                )
+            else:
+                response = await self.client.delete(
+                    f"{self.base_endpoint}/{namespace_id}/values/{key}"
+                )
+
+            return {
+                "success": True,
+                "key": key,
+                "namespace": namespace_type,
+                **response,
+            }
+
+        except CloudflareError as e:
+            logger.error(f"KV delete value failed: {e}")
+            raise
+
+    async def list_keys(
+        self,
+        namespace_type: str = "sessions",
+        prefix: str = "",
+        limit: int = 1000,
+        use_worker: bool = True,
+    ) -> Dict[str, Any]:
+        """List keys in KV namespace"""
+
+        namespace_id = self._get_namespace_id(namespace_type)
+
+        try:
+            if use_worker:
+                params = {"namespace": namespace_type, "prefix": prefix, "limit": limit}
+
+                query_string = "&".join([f"{k}={v}" for k, v in params.items() if v])
+                response = await self.client.get(
+                    f"api/kv/list?{query_string}", use_worker=True
+                )
+            else:
+                params = {"prefix": prefix, "limit": limit}
+
+                query_string = "&".join([f"{k}={v}" for k, v in params.items() if v])
+                response = await self.client.get(
+                    f"{self.base_endpoint}/{namespace_id}/keys?{query_string}"
+                )
+
+            return {
+                "namespace": namespace_type,
+                "prefix": prefix,
+                "keys": (
+                    response.get("result", [])
+                    if "result" in response
+                    else response.get("keys", [])
+                ),
+                **response,
+            }
+
+        except CloudflareError as e:
+            logger.error(f"KV list keys failed: {e}")
+            raise
+
+    # Session-specific methods
+    async def set_session(
+        self,
+        session_id: str,
+        session_data: Dict[str, Any],
+        ttl: int = 86400,  # 24 hours default
+    ) -> Dict[str, Any]:
+        """Set session data"""
+
+        data = {
+            **session_data,
+            "created_at": session_data.get("created_at", int(time.time())),
+            "expires_at": int(time.time()) + ttl,
+        }
+
+        return await self.set_value(f"session:{session_id}", data, "sessions", ttl)
+
+    async def get_session(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """Get session data"""
+
+        session = await self.get_value(f"session:{session_id}", "sessions")
+
+        if session and isinstance(session, dict):
+            # Check if session is expired
+            expires_at = session.get("expires_at")
+            if expires_at and int(time.time()) > expires_at:
+                await self.delete_session(session_id)
+                return None
+
+        return session
+
+    async def delete_session(self, session_id: str) -> Dict[str, Any]:
+        """Delete session data"""
+
+        return await self.delete_value(f"session:{session_id}", "sessions")
+
+    async def update_session(
+        self, session_id: str, updates: Dict[str, Any], extend_ttl: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """Update session data"""
+
+        existing_session = await self.get_session(session_id)
+
+        if not existing_session:
+            raise CloudflareError("Session not found")
+
+        updated_data = {**existing_session, **updates, "updated_at": int(time.time())}
+
+        # Calculate TTL
+        ttl = None
+        if extend_ttl:
+            ttl = extend_ttl
+        elif existing_session.get("expires_at"):
+            ttl = max(0, existing_session["expires_at"] - int(time.time()))
+
+        return await self.set_session(session_id, updated_data, ttl or 86400)
+
+    # Cache-specific methods
+    async def set_cache(
+        self, key: str, data: Any, ttl: int = 3600  # 1 hour default
+    ) -> Dict[str, Any]:
+        """Set cache data"""
+
+        cache_data = {
+            "data": data,
+            "cached_at": int(time.time()),
+            "expires_at": int(time.time()) + ttl,
+        }
+
+        return await self.set_value(f"cache:{key}", cache_data, "cache", ttl)
+
+    async def get_cache(self, key: str) -> Optional[Any]:
+        """Get cache data"""
+
+        cached = await self.get_value(f"cache:{key}", "cache")
+
+        if cached and isinstance(cached, dict):
+            # Check if cache is expired
+            expires_at = cached.get("expires_at")
+            if expires_at and int(time.time()) > expires_at:
+                await self.delete_cache(key)
+                return None
+
+            return cached.get("data")
+
+        return cached
+
+    async def delete_cache(self, key: str) -> Dict[str, Any]:
+        """Delete cache data"""
+
+        return await self.delete_value(f"cache:{key}", "cache")
+
+    # User-specific methods
+    async def set_user_cache(
+        self, user_id: str, key: str, data: Any, ttl: int = 3600
+    ) -> Dict[str, Any]:
+        """Set user-specific cache"""
+
+        user_key = f"user:{user_id}:{key}"
+        return await self.set_cache(user_key, data, ttl)
+
+    async def get_user_cache(self, user_id: str, key: str) -> Optional[Any]:
+        """Get user-specific cache"""
+
+        user_key = f"user:{user_id}:{key}"
+        return await self.get_cache(user_key)
+
+    async def delete_user_cache(self, user_id: str, key: str) -> Dict[str, Any]:
+        """Delete user-specific cache"""
+
+        user_key = f"user:{user_id}:{key}"
+        return await self.delete_cache(user_key)
+
+    async def get_user_cache_keys(self, user_id: str, limit: int = 100) -> List[str]:
+        """Get all cache keys for a user"""
+
+        result = await self.list_keys("cache", f"cache:user:{user_id}:", limit)
+
+        keys = []
+        for key_info in result.get("keys", []):
+            if isinstance(key_info, dict):
+                key = key_info.get("name", "")
+            else:
+                key = str(key_info)
+
+            # Remove prefix to get the actual key
+            if key.startswith(f"cache:user:{user_id}:"):
+                clean_key = key.replace(f"cache:user:{user_id}:", "")
+                keys.append(clean_key)
+
+        return keys
+
+    # Conversation caching
+    async def cache_conversation(
+        self,
+        conversation_id: str,
+        messages: List[Dict[str, Any]],
+        ttl: int = 7200,  # 2 hours default
+    ) -> Dict[str, Any]:
+        """Cache conversation messages"""
+
+        return await self.set_cache(
+            f"conversation:{conversation_id}",
+            {"messages": messages, "last_updated": int(time.time())},
+            ttl,
+        )
+
+    async def get_cached_conversation(
+        self, conversation_id: str
+    ) -> Optional[Dict[str, Any]]:
+        """Get cached conversation"""
+
+        return await self.get_cache(f"conversation:{conversation_id}")
+
+    # Agent execution caching
+    async def cache_agent_execution(
+        self, execution_id: str, execution_data: Dict[str, Any], ttl: int = 3600
+    ) -> Dict[str, Any]:
+        """Cache agent execution data"""
+
+        return await self.set_cache(f"execution:{execution_id}", execution_data, ttl)
+
+    async def get_cached_agent_execution(
+        self, execution_id: str
+    ) -> Optional[Dict[str, Any]]:
+        """Get cached agent execution"""
+
+        return await self.get_cache(f"execution:{execution_id}")
+
+    # Batch operations
+    async def set_batch(
+        self,
+        items: List[Dict[str, Any]],
+        namespace_type: str = "cache",
+        ttl: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Set multiple values (simulated batch operation)"""
+
+        results = []
+        successful = 0
+        failed = 0
+
+        for item in items:
+            try:
+                key = item["key"]
+                value = item["value"]
+                item_ttl = item.get("ttl", ttl)
+
+                result = await self.set_value(key, value, namespace_type, item_ttl)
+                results.append({"key": key, "success": True, "result": result})
+                successful += 1
+
+            except Exception as e:
+                results.append(
+                    {"key": item.get("key"), "success": False, "error": str(e)}
+                )
+                failed += 1
+
+        return {
+            "success": failed == 0,
+            "successful": successful,
+            "failed": failed,
+            "total": len(items),
+            "results": results,
+        }
+
+    async def get_batch(
+        self, keys: List[str], namespace_type: str = "cache"
+    ) -> Dict[str, Any]:
+        """Get multiple values (simulated batch operation)"""
+
+        results = {}
+
+        for key in keys:
+            try:
+                value = await self.get_value(key, namespace_type)
+                results[key] = value
+            except Exception as e:
+                logger.error(f"Failed to get key {key}: {e}")
+                results[key] = None
+
+        return results
+
+    def _hash_params(self, params: Dict[str, Any]) -> str:
+        """Create a hash for cache keys from parameters"""
+
+        if not params:
+            return "no-params"
+
+        # Simple hash function for cache keys
+        import hashlib
+
+        params_str = json.dumps(params, sort_keys=True)
+        return hashlib.md5(params_str.encode()).hexdigest()[:16]
+
+
+# Add time import at the top
+import time

app/cloudflare/r2.py

@@ -0,0 +1,434 @@
+"""
+R2 Storage integration for OpenManus
+Provides interface to Cloudflare R2 storage operations
+"""
+
+import io
+from typing import Any, BinaryIO, Dict, List, Optional
+
+from app.logger import logger
+
+from .client import CloudflareClient, CloudflareError
+
+
+class R2Storage:
+    """Cloudflare R2 Storage client"""
+
+    def __init__(
+        self,
+        client: CloudflareClient,
+        storage_bucket: str,
+        assets_bucket: Optional[str] = None,
+    ):
+        self.client = client
+        self.storage_bucket = storage_bucket
+        self.assets_bucket = assets_bucket or storage_bucket
+        self.base_endpoint = f"accounts/{client.account_id}/r2/buckets"
+
+    def _get_bucket_name(self, bucket_type: str = "storage") -> str:
+        """Get bucket name based on type"""
+        if bucket_type == "assets":
+            return self.assets_bucket
+        return self.storage_bucket
+
+    async def upload_file(
+        self,
+        key: str,
+        file_data: bytes,
+        content_type: str = "application/octet-stream",
+        bucket_type: str = "storage",
+        metadata: Optional[Dict[str, str]] = None,
+        use_worker: bool = True,
+    ) -> Dict[str, Any]:
+        """Upload a file to R2"""
+
+        bucket_name = self._get_bucket_name(bucket_type)
+
+        try:
+            if use_worker:
+                # Use worker endpoint for better performance
+                form_data = {
+                    "file": file_data,
+                    "bucket": bucket_type,
+                    "key": key,
+                    "contentType": content_type,
+                }
+
+                if metadata:
+                    form_data["metadata"] = metadata
+
+                response = await self.client.post(
+                    "api/files", data=form_data, use_worker=True
+                )
+            else:
+                # Use R2 API directly
+                headers = {"Content-Type": content_type}
+
+                if metadata:
+                    for k, v in metadata.items():
+                        headers[f"x-amz-meta-{k}"] = v
+
+                response = await self.client.upload_file(
+                    f"{self.base_endpoint}/{bucket_name}/objects/{key}",
+                    file_data,
+                    content_type,
+                    headers,
+                )
+
+            return {
+                "success": True,
+                "key": key,
+                "bucket": bucket_type,
+                "bucket_name": bucket_name,
+                "size": len(file_data),
+                "content_type": content_type,
+                "url": f"/{bucket_type}/{key}",
+                **response,
+            }
+
+        except CloudflareError as e:
+            logger.error(f"R2 upload failed: {e}")
+            raise
+
+    async def upload_file_stream(
+        self,
+        key: str,
+        file_stream: BinaryIO,
+        content_type: str = "application/octet-stream",
+        bucket_type: str = "storage",
+        metadata: Optional[Dict[str, str]] = None,
+    ) -> Dict[str, Any]:
+        """Upload a file from stream"""
+
+        file_data = file_stream.read()
+        return await self.upload_file(
+            key, file_data, content_type, bucket_type, metadata
+        )
+
+    async def get_file(
+        self, key: str, bucket_type: str = "storage", use_worker: bool = True
+    ) -> Optional[Dict[str, Any]]:
+        """Get a file from R2"""
+
+        bucket_name = self._get_bucket_name(bucket_type)
+
+        try:
+            if use_worker:
+                response = await self.client.get(
+                    f"api/files/{key}?bucket={bucket_type}", use_worker=True
+                )
+
+                if response:
+                    return {
+                        "key": key,
+                        "bucket": bucket_type,
+                        "bucket_name": bucket_name,
+                        "data": response,  # Binary data would be handled by worker
+                        "exists": True,
+                    }
+            else:
+                response = await self.client.get(
+                    f"{self.base_endpoint}/{bucket_name}/objects/{key}"
+                )
+
+                return {
+                    "key": key,
+                    "bucket": bucket_type,
+                    "bucket_name": bucket_name,
+                    "data": response,
+                    "exists": True,
+                }
+
+        except CloudflareError as e:
+            if e.status_code == 404:
+                return None
+            logger.error(f"R2 get file failed: {e}")
+            raise
+
+        return None
+
+    async def delete_file(
+        self, key: str, bucket_type: str = "storage", use_worker: bool = True
+    ) -> Dict[str, Any]:
+        """Delete a file from R2"""
+
+        bucket_name = self._get_bucket_name(bucket_type)
+
+        try:
+            if use_worker:
+                response = await self.client.delete(
+                    f"api/files/{key}?bucket={bucket_type}", use_worker=True
+                )
+            else:
+                response = await self.client.delete(
+                    f"{self.base_endpoint}/{bucket_name}/objects/{key}"
+                )
+
+            return {
+                "success": True,
+                "key": key,
+                "bucket": bucket_type,
+                "bucket_name": bucket_name,
+                **response,
+            }
+
+        except CloudflareError as e:
+            logger.error(f"R2 delete failed: {e}")
+            raise
+
+    async def list_files(
+        self,
+        bucket_type: str = "storage",
+        prefix: str = "",
+        limit: int = 1000,
+        use_worker: bool = True,
+    ) -> Dict[str, Any]:
+        """List files in R2 bucket"""
+
+        bucket_name = self._get_bucket_name(bucket_type)
+
+        try:
+            if use_worker:
+                params = {"bucket": bucket_type, "prefix": prefix, "limit": limit}
+
+                query_string = "&".join([f"{k}={v}" for k, v in params.items() if v])
+                response = await self.client.get(
+                    f"api/files/list?{query_string}", use_worker=True
+                )
+            else:
+                params = {"prefix": prefix, "max-keys": limit}
+
+                query_string = "&".join([f"{k}={v}" for k, v in params.items() if v])
+                response = await self.client.get(
+                    f"{self.base_endpoint}/{bucket_name}/objects?{query_string}"
+                )
+
+            return {
+                "bucket": bucket_type,
+                "bucket_name": bucket_name,
+                "prefix": prefix,
+                "files": response.get("objects", []),
+                "truncated": response.get("truncated", False),
+                **response,
+            }
+
+        except CloudflareError as e:
+            logger.error(f"R2 list files failed: {e}")
+            raise
+
+    async def get_file_metadata(
+        self, key: str, bucket_type: str = "storage", use_worker: bool = True
+    ) -> Optional[Dict[str, Any]]:
+        """Get file metadata without downloading content"""
+
+        bucket_name = self._get_bucket_name(bucket_type)
+
+        try:
+            if use_worker:
+                response = await self.client.get(
+                    f"api/files/{key}/metadata?bucket={bucket_type}", use_worker=True
+                )
+            else:
+                # Use HEAD request to get metadata only
+                response = await self.client.get(
+                    f"{self.base_endpoint}/{bucket_name}/objects/{key}",
+                    headers={"Range": "bytes=0-0"},  # Minimal range to get headers
+                )
+
+            if response:
+                return {
+                    "key": key,
+                    "bucket": bucket_type,
+                    "bucket_name": bucket_name,
+                    **response,
+                }
+
+        except CloudflareError as e:
+            if e.status_code == 404:
+                return None
+            logger.error(f"R2 get metadata failed: {e}")
+            raise
+
+        return None
+
+    async def copy_file(
+        self,
+        source_key: str,
+        destination_key: str,
+        source_bucket: str = "storage",
+        destination_bucket: str = "storage",
+        use_worker: bool = True,
+    ) -> Dict[str, Any]:
+        """Copy a file within R2 or between buckets"""
+
+        try:
+            if use_worker:
+                copy_data = {
+                    "sourceKey": source_key,
+                    "destinationKey": destination_key,
+                    "sourceBucket": source_bucket,
+                    "destinationBucket": destination_bucket,
+                }
+
+                response = await self.client.post(
+                    "api/files/copy", data=copy_data, use_worker=True
+                )
+            else:
+                # Get source file first
+                source_file = await self.get_file(source_key, source_bucket, False)
+
+                if not source_file:
+                    raise CloudflareError(f"Source file {source_key} not found")
+
+                # Upload to destination
+                response = await self.upload_file(
+                    destination_key,
+                    source_file["data"],
+                    bucket_type=destination_bucket,
+                    use_worker=False,
+                )
+
+            return {
+                "success": True,
+                "source_key": source_key,
+                "destination_key": destination_key,
+                "source_bucket": source_bucket,
+                "destination_bucket": destination_bucket,
+                **response,
+            }
+
+        except CloudflareError as e:
+            logger.error(f"R2 copy failed: {e}")
+            raise
+
+    async def move_file(
+        self,
+        source_key: str,
+        destination_key: str,
+        source_bucket: str = "storage",
+        destination_bucket: str = "storage",
+        use_worker: bool = True,
+    ) -> Dict[str, Any]:
+        """Move a file (copy then delete)"""
+
+        try:
+            # Copy file first
+            copy_result = await self.copy_file(
+                source_key,
+                destination_key,
+                source_bucket,
+                destination_bucket,
+                use_worker,
+            )
+
+            # Delete source file
+            delete_result = await self.delete_file(
+                source_key, source_bucket, use_worker
+            )
+
+            return {
+                "success": True,
+                "source_key": source_key,
+                "destination_key": destination_key,
+                "source_bucket": source_bucket,
+                "destination_bucket": destination_bucket,
+                "copy_result": copy_result,
+                "delete_result": delete_result,
+            }
+
+        except CloudflareError as e:
+            logger.error(f"R2 move failed: {e}")
+            raise
+
+    async def generate_presigned_url(
+        self,
+        key: str,
+        bucket_type: str = "storage",
+        expires_in: int = 3600,
+        method: str = "GET",
+    ) -> Dict[str, Any]:
+        """Generate a presigned URL for direct access"""
+
+        # Note: This would typically require additional R2 configuration
+        # For now, return a worker endpoint URL
+
+        try:
+            url_data = {
+                "key": key,
+                "bucket": bucket_type,
+                "expiresIn": expires_in,
+                "method": method,
+            }
+
+            response = await self.client.post(
+                "api/files/presigned-url", data=url_data, use_worker=True
+            )
+
+            return {
+                "success": True,
+                "key": key,
+                "bucket": bucket_type,
+                "method": method,
+                "expires_in": expires_in,
+                **response,
+            }
+
+        except CloudflareError as e:
+            logger.error(f"R2 presigned URL generation failed: {e}")
+            raise
+
+    async def get_storage_stats(self, use_worker: bool = True) -> Dict[str, Any]:
+        """Get storage statistics"""
+
+        try:
+            if use_worker:
+                response = await self.client.get("api/files/stats", use_worker=True)
+            else:
+                # Get stats for both buckets
+                storage_list = await self.list_files("storage", use_worker=False)
+                assets_list = await self.list_files("assets", use_worker=False)
+
+                storage_size = sum(
+                    file.get("size", 0) for file in storage_list.get("files", [])
+                )
+                assets_size = sum(
+                    file.get("size", 0) for file in assets_list.get("files", [])
+                )
+
+                response = {
+                    "storage": {
+                        "file_count": len(storage_list.get("files", [])),
+                        "total_size": storage_size,
+                    },
+                    "assets": {
+                        "file_count": len(assets_list.get("files", [])),
+                        "total_size": assets_size,
+                    },
+                    "total": {
+                        "file_count": len(storage_list.get("files", []))
+                        + len(assets_list.get("files", [])),
+                        "total_size": storage_size + assets_size,
+                    },
+                }
+
+            return response
+
+        except CloudflareError as e:
+            logger.error(f"R2 storage stats failed: {e}")
+            raise
+
+    def create_file_stream(self, data: bytes) -> io.BytesIO:
+        """Create a file stream from bytes"""
+        return io.BytesIO(data)
+
+    def get_public_url(self, key: str, bucket_type: str = "storage") -> str:
+        """Get public URL for a file (if bucket is configured for public access)"""
+        bucket_name = self._get_bucket_name(bucket_type)
+
+        # This would depend on your R2 custom domain configuration
+        # For now, return the worker endpoint
+        if self.client.worker_url:
+            return f"{self.client.worker_url}/api/files/{key}?bucket={bucket_type}"
+
+        # Default R2 URL format (requires public access configuration)
+        return f"https://pub-{bucket_name}.r2.dev/{key}"

app/config.py

@@ -0,0 +1,372 @@
+import json
+import threading
+import tomllib
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+def get_project_root() -> Path:
+    """Get the project root directory"""
+    return Path(__file__).resolve().parent.parent
+
+
+PROJECT_ROOT = get_project_root()
+WORKSPACE_ROOT = PROJECT_ROOT / "workspace"
+
+
+class LLMSettings(BaseModel):
+    model: str = Field(..., description="Model name")
+    base_url: str = Field(..., description="API base URL")
+    api_key: str = Field(..., description="API key")
+    max_tokens: int = Field(4096, description="Maximum number of tokens per request")
+    max_input_tokens: Optional[int] = Field(
+        None,
+        description="Maximum input tokens to use across all requests (None for unlimited)",
+    )
+    temperature: float = Field(1.0, description="Sampling temperature")
+    api_type: str = Field(..., description="Azure, Openai, or Ollama")
+    api_version: str = Field(..., description="Azure Openai version if AzureOpenai")
+
+
+class ProxySettings(BaseModel):
+    server: str = Field(None, description="Proxy server address")
+    username: Optional[str] = Field(None, description="Proxy username")
+    password: Optional[str] = Field(None, description="Proxy password")
+
+
+class SearchSettings(BaseModel):
+    engine: str = Field(default="Google", description="Search engine the llm to use")
+    fallback_engines: List[str] = Field(
+        default_factory=lambda: ["DuckDuckGo", "Baidu", "Bing"],
+        description="Fallback search engines to try if the primary engine fails",
+    )
+    retry_delay: int = Field(
+        default=60,
+        description="Seconds to wait before retrying all engines again after they all fail",
+    )
+    max_retries: int = Field(
+        default=3,
+        description="Maximum number of times to retry all engines when all fail",
+    )
+    lang: str = Field(
+        default="en",
+        description="Language code for search results (e.g., en, zh, fr)",
+    )
+    country: str = Field(
+        default="us",
+        description="Country code for search results (e.g., us, cn, uk)",
+    )
+
+
+class RunflowSettings(BaseModel):
+    use_data_analysis_agent: bool = Field(
+        default=False, description="Enable data analysis agent in run flow"
+    )
+
+
+class BrowserSettings(BaseModel):
+    headless: bool = Field(False, description="Whether to run browser in headless mode")
+    disable_security: bool = Field(
+        True, description="Disable browser security features"
+    )
+    extra_chromium_args: List[str] = Field(
+        default_factory=list, description="Extra arguments to pass to the browser"
+    )
+    chrome_instance_path: Optional[str] = Field(
+        None, description="Path to a Chrome instance to use"
+    )
+    wss_url: Optional[str] = Field(
+        None, description="Connect to a browser instance via WebSocket"
+    )
+    cdp_url: Optional[str] = Field(
+        None, description="Connect to a browser instance via CDP"
+    )
+    proxy: Optional[ProxySettings] = Field(
+        None, description="Proxy settings for the browser"
+    )
+    max_content_length: int = Field(
+        2000, description="Maximum length for content retrieval operations"
+    )
+
+
+class SandboxSettings(BaseModel):
+    """Configuration for the execution sandbox"""
+
+    use_sandbox: bool = Field(False, description="Whether to use the sandbox")
+    image: str = Field("python:3.12-slim", description="Base image")
+    work_dir: str = Field("/workspace", description="Container working directory")
+    memory_limit: str = Field("512m", description="Memory limit")
+    cpu_limit: float = Field(1.0, description="CPU limit")
+    timeout: int = Field(300, description="Default command timeout (seconds)")
+    network_enabled: bool = Field(
+        False, description="Whether network access is allowed"
+    )
+
+
+class DaytonaSettings(BaseModel):
+    daytona_api_key: str
+    daytona_server_url: Optional[str] = Field(
+        "https://app.daytona.io/api", description=""
+    )
+    daytona_target: Optional[str] = Field("us", description="enum ['eu', 'us']")
+    sandbox_image_name: Optional[str] = Field("whitezxj/sandbox:0.1.0", description="")
+    sandbox_entrypoint: Optional[str] = Field(
+        "/usr/bin/supervisord -n -c /etc/supervisor/conf.d/supervisord.conf",
+        description="",
+    )
+    # sandbox_id: Optional[str] = Field(
+    #     None, description="ID of the daytona sandbox to use, if any"
+    # )
+    VNC_password: Optional[str] = Field(
+        "123456", description="VNC password for the vnc service in sandbox"
+    )
+
+
+class MCPServerConfig(BaseModel):
+    """Configuration for a single MCP server"""
+
+    type: str = Field(..., description="Server connection type (sse or stdio)")
+    url: Optional[str] = Field(None, description="Server URL for SSE connections")
+    command: Optional[str] = Field(None, description="Command for stdio connections")
+    args: List[str] = Field(
+        default_factory=list, description="Arguments for stdio command"
+    )
+
+
+class MCPSettings(BaseModel):
+    """Configuration for MCP (Model Context Protocol)"""
+
+    server_reference: str = Field(
+        "app.mcp.server", description="Module reference for the MCP server"
+    )
+    servers: Dict[str, MCPServerConfig] = Field(
+        default_factory=dict, description="MCP server configurations"
+    )
+
+    @classmethod
+    def load_server_config(cls) -> Dict[str, MCPServerConfig]:
+        """Load MCP server configuration from JSON file"""
+        config_path = PROJECT_ROOT / "config" / "mcp.json"
+
+        try:
+            config_file = config_path if config_path.exists() else None
+            if not config_file:
+                return {}
+
+            with config_file.open() as f:
+                data = json.load(f)
+                servers = {}
+
+                for server_id, server_config in data.get("mcpServers", {}).items():
+                    servers[server_id] = MCPServerConfig(
+                        type=server_config["type"],
+                        url=server_config.get("url"),
+                        command=server_config.get("command"),
+                        args=server_config.get("args", []),
+                    )
+                return servers
+        except Exception as e:
+            raise ValueError(f"Failed to load MCP server config: {e}")
+
+
+class AppConfig(BaseModel):
+    llm: Dict[str, LLMSettings]
+    sandbox: Optional[SandboxSettings] = Field(
+        None, description="Sandbox configuration"
+    )
+    browser_config: Optional[BrowserSettings] = Field(
+        None, description="Browser configuration"
+    )
+    search_config: Optional[SearchSettings] = Field(
+        None, description="Search configuration"
+    )
+    mcp_config: Optional[MCPSettings] = Field(None, description="MCP configuration")
+    run_flow_config: Optional[RunflowSettings] = Field(
+        None, description="Run flow configuration"
+    )
+    daytona_config: Optional[DaytonaSettings] = Field(
+        None, description="Daytona configuration"
+    )
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class Config:
+    _instance = None
+    _lock = threading.Lock()
+    _initialized = False
+
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if not self._initialized:
+            with self._lock:
+                if not self._initialized:
+                    self._config = None
+                    self._load_initial_config()
+                    self._initialized = True
+
+    @staticmethod
+    def _get_config_path() -> Path:
+        root = PROJECT_ROOT
+        config_path = root / "config" / "config.toml"
+        if config_path.exists():
+            return config_path
+        example_path = root / "config" / "config.example.toml"
+        if example_path.exists():
+            return example_path
+        raise FileNotFoundError("No configuration file found in config directory")
+
+    def _load_config(self) -> dict:
+        config_path = self._get_config_path()
+        with config_path.open("rb") as f:
+            return tomllib.load(f)
+
+    def _load_initial_config(self):
+        raw_config = self._load_config()
+        base_llm = raw_config.get("llm", {})
+        llm_overrides = {
+            k: v for k, v in raw_config.get("llm", {}).items() if isinstance(v, dict)
+        }
+
+        default_settings = {
+            "model": base_llm.get("model"),
+            "base_url": base_llm.get("base_url"),
+            "api_key": base_llm.get("api_key"),
+            "max_tokens": base_llm.get("max_tokens", 4096),
+            "max_input_tokens": base_llm.get("max_input_tokens"),
+            "temperature": base_llm.get("temperature", 1.0),
+            "api_type": base_llm.get("api_type", ""),
+            "api_version": base_llm.get("api_version", ""),
+        }
+
+        # handle browser config.
+        browser_config = raw_config.get("browser", {})
+        browser_settings = None
+
+        if browser_config:
+            # handle proxy settings.
+            proxy_config = browser_config.get("proxy", {})
+            proxy_settings = None
+
+            if proxy_config and proxy_config.get("server"):
+                proxy_settings = ProxySettings(
+                    **{
+                        k: v
+                        for k, v in proxy_config.items()
+                        if k in ["server", "username", "password"] and v
+                    }
+                )
+
+            # filter valid browser config parameters.
+            valid_browser_params = {
+                k: v
+                for k, v in browser_config.items()
+                if k in BrowserSettings.__annotations__ and v is not None
+            }
+
+            # if there is proxy settings, add it to the parameters.
+            if proxy_settings:
+                valid_browser_params["proxy"] = proxy_settings
+
+            # only create BrowserSettings when there are valid parameters.
+            if valid_browser_params:
+                browser_settings = BrowserSettings(**valid_browser_params)
+
+        search_config = raw_config.get("search", {})
+        search_settings = None
+        if search_config:
+            search_settings = SearchSettings(**search_config)
+        sandbox_config = raw_config.get("sandbox", {})
+        if sandbox_config:
+            sandbox_settings = SandboxSettings(**sandbox_config)
+        else:
+            sandbox_settings = SandboxSettings()
+        daytona_config = raw_config.get("daytona", {})
+        if daytona_config:
+            daytona_settings = DaytonaSettings(**daytona_config)
+        else:
+            daytona_settings = DaytonaSettings()
+
+        mcp_config = raw_config.get("mcp", {})
+        mcp_settings = None
+        if mcp_config:
+            # Load server configurations from JSON
+            mcp_config["servers"] = MCPSettings.load_server_config()
+            mcp_settings = MCPSettings(**mcp_config)
+        else:
+            mcp_settings = MCPSettings(servers=MCPSettings.load_server_config())
+
+        run_flow_config = raw_config.get("runflow")
+        if run_flow_config:
+            run_flow_settings = RunflowSettings(**run_flow_config)
+        else:
+            run_flow_settings = RunflowSettings()
+        config_dict = {
+            "llm": {
+                "default": default_settings,
+                **{
+                    name: {**default_settings, **override_config}
+                    for name, override_config in llm_overrides.items()
+                },
+            },
+            "sandbox": sandbox_settings,
+            "browser_config": browser_settings,
+            "search_config": search_settings,
+            "mcp_config": mcp_settings,
+            "run_flow_config": run_flow_settings,
+            "daytona_config": daytona_settings,
+        }
+
+        self._config = AppConfig(**config_dict)
+
+    @property
+    def llm(self) -> Dict[str, LLMSettings]:
+        return self._config.llm
+
+    @property
+    def sandbox(self) -> SandboxSettings:
+        return self._config.sandbox
+
+    @property
+    def daytona(self) -> DaytonaSettings:
+        return self._config.daytona_config
+
+    @property
+    def browser_config(self) -> Optional[BrowserSettings]:
+        return self._config.browser_config
+
+    @property
+    def search_config(self) -> Optional[SearchSettings]:
+        return self._config.search_config
+
+    @property
+    def mcp_config(self) -> MCPSettings:
+        """Get the MCP configuration"""
+        return self._config.mcp_config
+
+    @property
+    def run_flow_config(self) -> RunflowSettings:
+        """Get the Run Flow configuration"""
+        return self._config.run_flow_config
+
+    @property
+    def workspace_root(self) -> Path:
+        """Get the workspace root directory"""
+        return WORKSPACE_ROOT
+
+    @property
+    def root_path(self) -> Path:
+        """Get the root path of the application"""
+        return PROJECT_ROOT
+
+
+config = Config()

app/logger.py

@@ -0,0 +1,42 @@
+import sys
+from datetime import datetime
+
+from loguru import logger as _logger
+
+from app.config import PROJECT_ROOT
+
+
+_print_level = "INFO"
+
+
+def define_log_level(print_level="INFO", logfile_level="DEBUG", name: str = None):
+    """Adjust the log level to above level"""
+    global _print_level
+    _print_level = print_level
+
+    current_date = datetime.now()
+    formatted_date = current_date.strftime("%Y%m%d%H%M%S")
+    log_name = (
+        f"{name}_{formatted_date}" if name else formatted_date
+    )  # name a log with prefix name
+
+    _logger.remove()
+    _logger.add(sys.stderr, level=print_level)
+    _logger.add(PROJECT_ROOT / f"logs/{log_name}.log", level=logfile_level)
+    return _logger
+
+
+logger = define_log_level()
+
+
+if __name__ == "__main__":
+    logger.info("Starting application")
+    logger.debug("Debug message")
+    logger.warning("Warning message")
+    logger.error("Error message")
+    logger.critical("Critical message")
+
+    try:
+        raise ValueError("Test error")
+    except Exception as e:
+        logger.exception(f"An error occurred: {e}")

app/production_config.py

@@ -0,0 +1,363 @@
+"""
+Complete Configuration for OpenManus Production Deployment
+Includes: All model configurations, agent settings, category mappings, and service configurations
+"""
+
+import os
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass
+from enum import Enum
+
+
+@dataclass
+class ModelConfig:
+    """Configuration for individual AI models"""
+
+    name: str
+    category: str
+    api_endpoint: str
+    max_tokens: int = 4096
+    temperature: float = 0.7
+    supported_formats: List[str] = None
+    special_parameters: Dict[str, Any] = None
+    rate_limit: int = 100  # requests per minute
+
+
+class CategoryConfig:
+    """Configuration for model categories"""
+
+    # Core AI Models - Text Generation (Qwen, DeepSeek, etc.)
+    TEXT_GENERATION_MODELS = {
+        # Qwen Models (35 models)
+        "qwen/qwen-2.5-72b-instruct": ModelConfig(
+            name="Qwen 2.5 72B Instruct",
+            category="text-generation",
+            api_endpoint="https://api-inference.huggingface.co/models/Qwen/Qwen2.5-72B-Instruct",
+            max_tokens=8192,
+            temperature=0.7,
+        ),
+        "qwen/qwen-2.5-32b-instruct": ModelConfig(
+            name="Qwen 2.5 32B Instruct",
+            category="text-generation",
+            api_endpoint="https://api-inference.huggingface.co/models/Qwen/Qwen2.5-32B-Instruct",
+            max_tokens=8192,
+        ),
+        "qwen/qwen-2.5-14b-instruct": ModelConfig(
+            name="Qwen 2.5 14B Instruct",
+            category="text-generation",
+            api_endpoint="https://api-inference.huggingface.co/models/Qwen/Qwen2.5-14B-Instruct",
+            max_tokens=8192,
+        ),
+        "qwen/qwen-2.5-7b-instruct": ModelConfig(
+            name="Qwen 2.5 7B Instruct",
+            category="text-generation",
+            api_endpoint="https://api-inference.huggingface.co/models/Qwen/Qwen2.5-7B-Instruct",
+        ),
+        "qwen/qwen-2.5-3b-instruct": ModelConfig(
+            name="Qwen 2.5 3B Instruct",
+            category="text-generation",
+            api_endpoint="https://api-inference.huggingface.co/models/Qwen/Qwen2.5-3B-Instruct",
+        ),
+        "qwen/qwen-2.5-1.5b-instruct": ModelConfig(
+            name="Qwen 2.5 1.5B Instruct",
+            category="text-generation",
+            api_endpoint="https://api-inference.huggingface.co/models/Qwen/Qwen2.5-1.5B-Instruct",
+        ),
+        "qwen/qwen-2.5-0.5b-instruct": ModelConfig(
+            name="Qwen 2.5 0.5B Instruct",
+            category="text-generation",
+            api_endpoint="https://api-inference.huggingface.co/models/Qwen/Qwen2.5-0.5B-Instruct",
+        ),
+        # ... (Add all 35 Qwen models)
+        # DeepSeek Models (17 models)
+        "deepseek-ai/deepseek-coder-33b-instruct": ModelConfig(
+            name="DeepSeek Coder 33B Instruct",
+            category="code-generation",
+            api_endpoint="https://api-inference.huggingface.co/models/deepseek-ai/deepseek-coder-33b-instruct",
+            max_tokens=8192,
+            special_parameters={"code_focused": True},
+        ),
+        "deepseek-ai/deepseek-coder-6.7b-instruct": ModelConfig(
+            name="DeepSeek Coder 6.7B Instruct",
+            category="code-generation",
+            api_endpoint="https://api-inference.huggingface.co/models/deepseek-ai/deepseek-coder-6.7b-instruct",
+        ),
+        # ... (Add all 17 DeepSeek models)
+    }
+
+    # Image Editing Models (10 models)
+    IMAGE_EDITING_MODELS = {
+        "stabilityai/stable-diffusion-xl-refiner-1.0": ModelConfig(
+            name="SDXL Refiner 1.0",
+            category="image-editing",
+            api_endpoint="https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-refiner-1.0",
+            supported_formats=["image/png", "image/jpeg"],
+        ),
+        "runwayml/stable-diffusion-inpainting": ModelConfig(
+            name="Stable Diffusion Inpainting",
+            category="image-inpainting",
+            api_endpoint="https://api-inference.huggingface.co/models/runwayml/stable-diffusion-inpainting",
+            supported_formats=["image/png", "image/jpeg"],
+        ),
+        # ... (Add all 10 image editing models)
+    }
+
+    # TTS/STT Models (15 models)
+    SPEECH_MODELS = {
+        "microsoft/speecht5_tts": ModelConfig(
+            name="SpeechT5 TTS",
+            category="text-to-speech",
+            api_endpoint="https://api-inference.huggingface.co/models/microsoft/speecht5_tts",
+            supported_formats=["audio/wav", "audio/mp3"],
+        ),
+        "openai/whisper-large-v3": ModelConfig(
+            name="Whisper Large v3",
+            category="automatic-speech-recognition",
+            api_endpoint="https://api-inference.huggingface.co/models/openai/whisper-large-v3",
+            supported_formats=["audio/wav", "audio/mp3", "audio/flac"],
+        ),
+        # ... (Add all 15 speech models)
+    }
+
+    # Face Swap Models (6 models)
+    FACE_SWAP_MODELS = {
+        "deepinsight/insightface": ModelConfig(
+            name="InsightFace",
+            category="face-swap",
+            api_endpoint="https://api-inference.huggingface.co/models/deepinsight/insightface",
+            supported_formats=["image/png", "image/jpeg"],
+        ),
+        # ... (Add all 6 face swap models)
+    }
+
+    # Talking Avatar Models (9 models)
+    AVATAR_MODELS = {
+        "microsoft/DiT-XL-2-512": ModelConfig(
+            name="DiT Avatar Generator",
+            category="talking-avatar",
+            api_endpoint="https://api-inference.huggingface.co/models/microsoft/DiT-XL-2-512",
+            supported_formats=["video/mp4", "image/png"],
+        ),
+        # ... (Add all 9 avatar models)
+    }
+
+    # Arabic-English Interactive Models (12 models)
+    ARABIC_ENGLISH_MODELS = {
+        "aubmindlab/bert-base-arabertv02": ModelConfig(
+            name="AraBERT v02",
+            category="arabic-text",
+            api_endpoint="https://api-inference.huggingface.co/models/aubmindlab/bert-base-arabertv02",
+            special_parameters={"language": "ar-en"},
+        ),
+        "UBC-NLP/MARBERT": ModelConfig(
+            name="MARBERT",
+            category="arabic-text",
+            api_endpoint="https://api-inference.huggingface.co/models/UBC-NLP/MARBERT",
+            special_parameters={"language": "ar-en"},
+        ),
+        # ... (Add all 12 Arabic-English models)
+    }
+
+
+class AgentConfig:
+    """Configuration for AI Agents"""
+
+    # Manus Agent Configuration
+    MANUS_AGENT = {
+        "name": "Manus",
+        "description": "Versatile AI agent with 200+ models",
+        "max_steps": 20,
+        "max_observe": 10000,
+        "system_prompt_template": """You are Manus, an advanced AI agent with access to 200+ specialized models.
+
+Available categories:
+- Text Generation (Qwen, DeepSeek, etc.)
+- Image Editing & Generation
+- Speech (TTS/STT)
+- Face Swap & Avatar Generation
+- Arabic-English Interactive Models
+- Code Generation & Review
+- Multimodal AI
+- Document Processing
+- 3D Generation
+- Video Processing
+
+User workspace: {directory}""",
+        "tools": [
+            "PythonExecute",
+            "BrowserUseTool",
+            "StrReplaceEditor",
+            "AskHuman",
+            "Terminate",
+            "HuggingFaceModels",
+        ],
+        "model_preferences": {
+            "text": "qwen/qwen-2.5-72b-instruct",
+            "code": "deepseek-ai/deepseek-coder-33b-instruct",
+            "image": "stabilityai/stable-diffusion-xl-refiner-1.0",
+            "speech": "microsoft/speecht5_tts",
+            "arabic": "aubmindlab/bert-base-arabertv02",
+        },
+    }
+
+
+class ServiceConfig:
+    """Configuration for all services"""
+
+    # Cloudflare Services
+    CLOUDFLARE_CONFIG = {
+        "d1_database": {
+            "enabled": True,
+            "tables": ["users", "sessions", "agent_interactions", "model_usage"],
+            "auto_migrate": True,
+        },
+        "r2_storage": {
+            "enabled": True,
+            "buckets": ["user-files", "generated-content", "model-cache"],
+            "max_file_size": "100MB",
+        },
+        "kv_storage": {
+            "enabled": True,
+            "namespaces": ["sessions", "model-cache", "user-preferences"],
+            "ttl": 86400,  # 24 hours
+        },
+        "durable_objects": {
+            "enabled": True,
+            "classes": ["ChatSession", "ModelRouter", "UserContext"],
+        },
+    }
+
+    # Authentication Configuration
+    AUTH_CONFIG = {
+        "method": "mobile_password",
+        "password_min_length": 8,
+        "session_duration": 86400,  # 24 hours
+        "max_concurrent_sessions": 5,
+        "mobile_validation": {
+            "international": True,
+            "formats": ["+1234567890", "01234567890"],
+        },
+    }
+
+    # Model Usage Configuration
+    MODEL_CONFIG = {
+        "rate_limits": {
+            "free_tier": 100,  # requests per day
+            "premium_tier": 1000,
+            "enterprise_tier": 10000,
+        },
+        "fallback_models": {
+            "text": ["qwen/qwen-2.5-7b-instruct", "qwen/qwen-2.5-3b-instruct"],
+            "image": ["runwayml/stable-diffusion-v1-5"],
+            "code": ["deepseek-ai/deepseek-coder-6.7b-instruct"],
+        },
+        "cache_settings": {"enabled": True, "ttl": 3600, "max_size": "1GB"},  # 1 hour
+    }
+
+
+class EnvironmentConfig:
+    """Environment-specific configurations"""
+
+    @staticmethod
+    def get_production_config():
+        """Get production environment configuration"""
+        return {
+            "environment": "production",
+            "debug": False,
+            "log_level": "INFO",
+            "server": {"host": "0.0.0.0", "port": 7860, "workers": 4},
+            "database": {"type": "sqlite", "url": "auth.db", "pool_size": 10},
+            "security": {
+                "secret_key": os.getenv("SECRET_KEY", "your-secret-key"),
+                "cors_origins": ["*"],
+                "rate_limiting": True,
+            },
+            "monitoring": {"metrics": True, "logging": True, "health_checks": True},
+        }
+
+    @staticmethod
+    def get_development_config():
+        """Get development environment configuration"""
+        return {
+            "environment": "development",
+            "debug": True,
+            "log_level": "DEBUG",
+            "server": {"host": "127.0.0.1", "port": 7860, "workers": 1},
+            "database": {"type": "sqlite", "url": "auth_dev.db", "pool_size": 2},
+            "security": {
+                "secret_key": "dev-secret-key",
+                "cors_origins": ["http://localhost:*"],
+                "rate_limiting": False,
+            },
+        }
+
+
+# Global configuration instance
+class OpenManusConfig:
+    """Main configuration class for OpenManus"""
+
+    def __init__(self, environment: str = "production"):
+        self.environment = environment
+        self.categories = CategoryConfig()
+        self.agent = AgentConfig()
+        self.services = ServiceConfig()
+
+        if environment == "production":
+            self.env_config = EnvironmentConfig.get_production_config()
+        else:
+            self.env_config = EnvironmentConfig.get_development_config()
+
+    def get_model_config(self, model_id: str) -> Optional[ModelConfig]:
+        """Get configuration for a specific model"""
+        all_models = {
+            **self.categories.TEXT_GENERATION_MODELS,
+            **self.categories.IMAGE_EDITING_MODELS,
+            **self.categories.SPEECH_MODELS,
+            **self.categories.FACE_SWAP_MODELS,
+            **self.categories.AVATAR_MODELS,
+            **self.categories.ARABIC_ENGLISH_MODELS,
+        }
+        return all_models.get(model_id)
+
+    def get_category_models(self, category: str) -> Dict[str, ModelConfig]:
+        """Get all models in a category"""
+        if category == "text-generation":
+            return self.categories.TEXT_GENERATION_MODELS
+        elif category == "image-editing":
+            return self.categories.IMAGE_EDITING_MODELS
+        elif category in ["text-to-speech", "automatic-speech-recognition"]:
+            return self.categories.SPEECH_MODELS
+        elif category == "face-swap":
+            return self.categories.FACE_SWAP_MODELS
+        elif category == "talking-avatar":
+            return self.categories.AVATAR_MODELS
+        elif category == "arabic-text":
+            return self.categories.ARABIC_ENGLISH_MODELS
+        else:
+            return {}
+
+    def validate_config(self) -> bool:
+        """Validate the configuration"""
+        try:
+            # Check required environment variables
+            required_env = (
+                ["CLOUDFLARE_API_TOKEN", "HF_TOKEN"]
+                if self.environment == "production"
+                else []
+            )
+            missing_env = [var for var in required_env if not os.getenv(var)]
+
+            if missing_env:
+                print(f"Missing required environment variables: {missing_env}")
+                return False
+
+            print(f"Configuration validated for {self.environment} environment")
+            return True
+
+        except Exception as e:
+            print(f"Configuration validation failed: {e}")
+            return False
+
+
+# Create global config instance
+config = OpenManusConfig(environment=os.getenv("ENVIRONMENT", "production"))

app/prompt/manus.py

@@ -0,0 +1,10 @@
+SYSTEM_PROMPT = (
+    "You are OpenManus, an all-capable AI assistant, aimed at solving any task presented by the user. You have various tools at your disposal that you can call upon to efficiently complete complex requests. Whether it's programming, information retrieval, file processing, web browsing, or human interaction (only for extreme cases), you can handle it all."
+    "The initial directory is: {directory}"
+)
+
+NEXT_STEP_PROMPT = """
+Based on user needs, proactively select the most appropriate tool or combination of tools. For complex tasks, you can break down the problem and use different tools step by step to solve it. After using each tool, clearly explain the execution results and suggest the next steps.
+
+If you want to stop the interaction at any point, use the `terminate` tool/function call.
+"""

app/schema.py

@@ -0,0 +1,187 @@
+from enum import Enum
+from typing import Any, List, Literal, Optional, Union
+
+from pydantic import BaseModel, Field
+
+
+class Role(str, Enum):
+    """Message role options"""
+
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
+    TOOL = "tool"
+
+
+ROLE_VALUES = tuple(role.value for role in Role)
+ROLE_TYPE = Literal[ROLE_VALUES]  # type: ignore
+
+
+class ToolChoice(str, Enum):
+    """Tool choice options"""
+
+    NONE = "none"
+    AUTO = "auto"
+    REQUIRED = "required"
+
+
+TOOL_CHOICE_VALUES = tuple(choice.value for choice in ToolChoice)
+TOOL_CHOICE_TYPE = Literal[TOOL_CHOICE_VALUES]  # type: ignore
+
+
+class AgentState(str, Enum):
+    """Agent execution states"""
+
+    IDLE = "IDLE"
+    RUNNING = "RUNNING"
+    FINISHED = "FINISHED"
+    ERROR = "ERROR"
+
+
+class Function(BaseModel):
+    name: str
+    arguments: str
+
+
+class ToolCall(BaseModel):
+    """Represents a tool/function call in a message"""
+
+    id: str
+    type: str = "function"
+    function: Function
+
+
+class Message(BaseModel):
+    """Represents a chat message in the conversation"""
+
+    role: ROLE_TYPE = Field(...)  # type: ignore
+    content: Optional[str] = Field(default=None)
+    tool_calls: Optional[List[ToolCall]] = Field(default=None)
+    name: Optional[str] = Field(default=None)
+    tool_call_id: Optional[str] = Field(default=None)
+    base64_image: Optional[str] = Field(default=None)
+
+    def __add__(self, other) -> List["Message"]:
+        """支持 Message + list 或 Message + Message 的操作"""
+        if isinstance(other, list):
+            return [self] + other
+        elif isinstance(other, Message):
+            return [self, other]
+        else:
+            raise TypeError(
+                f"unsupported operand type(s) for +: '{type(self).__name__}' and '{type(other).__name__}'"
+            )
+
+    def __radd__(self, other) -> List["Message"]:
+        """支持 list + Message 的操作"""
+        if isinstance(other, list):
+            return other + [self]
+        else:
+            raise TypeError(
+                f"unsupported operand type(s) for +: '{type(other).__name__}' and '{type(self).__name__}'"
+            )
+
+    def to_dict(self) -> dict:
+        """Convert message to dictionary format"""
+        message = {"role": self.role}
+        if self.content is not None:
+            message["content"] = self.content
+        if self.tool_calls is not None:
+            message["tool_calls"] = [tool_call.dict() for tool_call in self.tool_calls]
+        if self.name is not None:
+            message["name"] = self.name
+        if self.tool_call_id is not None:
+            message["tool_call_id"] = self.tool_call_id
+        if self.base64_image is not None:
+            message["base64_image"] = self.base64_image
+        return message
+
+    @classmethod
+    def user_message(
+        cls, content: str, base64_image: Optional[str] = None
+    ) -> "Message":
+        """Create a user message"""
+        return cls(role=Role.USER, content=content, base64_image=base64_image)
+
+    @classmethod
+    def system_message(cls, content: str) -> "Message":
+        """Create a system message"""
+        return cls(role=Role.SYSTEM, content=content)
+
+    @classmethod
+    def assistant_message(
+        cls, content: Optional[str] = None, base64_image: Optional[str] = None
+    ) -> "Message":
+        """Create an assistant message"""
+        return cls(role=Role.ASSISTANT, content=content, base64_image=base64_image)
+
+    @classmethod
+    def tool_message(
+        cls, content: str, name, tool_call_id: str, base64_image: Optional[str] = None
+    ) -> "Message":
+        """Create a tool message"""
+        return cls(
+            role=Role.TOOL,
+            content=content,
+            name=name,
+            tool_call_id=tool_call_id,
+            base64_image=base64_image,
+        )
+
+    @classmethod
+    def from_tool_calls(
+        cls,
+        tool_calls: List[Any],
+        content: Union[str, List[str]] = "",
+        base64_image: Optional[str] = None,
+        **kwargs,
+    ):
+        """Create ToolCallsMessage from raw tool calls.
+
+        Args:
+            tool_calls: Raw tool calls from LLM
+            content: Optional message content
+            base64_image: Optional base64 encoded image
+        """
+        formatted_calls = [
+            {"id": call.id, "function": call.function.model_dump(), "type": "function"}
+            for call in tool_calls
+        ]
+        return cls(
+            role=Role.ASSISTANT,
+            content=content,
+            tool_calls=formatted_calls,
+            base64_image=base64_image,
+            **kwargs,
+        )
+
+
+class Memory(BaseModel):
+    messages: List[Message] = Field(default_factory=list)
+    max_messages: int = Field(default=100)
+
+    def add_message(self, message: Message) -> None:
+        """Add a message to memory"""
+        self.messages.append(message)
+        # Optional: Implement message limit
+        if len(self.messages) > self.max_messages:
+            self.messages = self.messages[-self.max_messages :]
+
+    def add_messages(self, messages: List[Message]) -> None:
+        """Add multiple messages to memory"""
+        self.messages.extend(messages)
+        # Optional: Implement message limit
+        if len(self.messages) > self.max_messages:
+            self.messages = self.messages[-self.max_messages :]
+
+    def clear(self) -> None:
+        """Clear all messages"""
+        self.messages.clear()
+
+    def get_recent_messages(self, n: int) -> List[Message]:
+        """Get n most recent messages"""
+        return self.messages[-n:]
+
+    def to_dict_list(self) -> List[dict]:
+        """Convert messages to list of dicts"""
+        return [msg.to_dict() for msg in self.messages]

app/tool/__init__.py

@@ -0,0 +1,24 @@
+from app.tool.base import BaseTool
+from app.tool.bash import Bash
+from app.tool.browser_use_tool import BrowserUseTool
+from app.tool.crawl4ai import Crawl4aiTool
+from app.tool.create_chat_completion import CreateChatCompletion
+from app.tool.planning import PlanningTool
+from app.tool.str_replace_editor import StrReplaceEditor
+from app.tool.terminate import Terminate
+from app.tool.tool_collection import ToolCollection
+from app.tool.web_search import WebSearch
+
+
+__all__ = [
+    "BaseTool",
+    "Bash",
+    "BrowserUseTool",
+    "Terminate",
+    "StrReplaceEditor",
+    "WebSearch",
+    "ToolCollection",
+    "CreateChatCompletion",
+    "PlanningTool",
+    "Crawl4aiTool",
+]

app/tool/ask_human.py

@@ -0,0 +1,21 @@
+from app.tool import BaseTool
+
+
+class AskHuman(BaseTool):
+    """Add a tool to ask human for help."""
+
+    name: str = "ask_human"
+    description: str = "Use this tool to ask human for help."
+    parameters: str = {
+        "type": "object",
+        "properties": {
+            "inquire": {
+                "type": "string",
+                "description": "The question you want to ask human.",
+            }
+        },
+        "required": ["inquire"],
+    }
+
+    async def execute(self, inquire: str) -> str:
+        return input(f"""Bot: {inquire}\n\nYou: """).strip()

app/tool/base.py

@@ -0,0 +1,181 @@
+import json
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional, Union
+
+from pydantic import BaseModel, Field
+
+from app.utils.logger import logger
+
+
+# class BaseTool(ABC, BaseModel):
+#     name: str
+#     description: str
+#     parameters: Optional[dict] = None
+
+#     class Config:
+#         arbitrary_types_allowed = True
+
+#     async def __call__(self, **kwargs) -> Any:
+#         """Execute the tool with given parameters."""
+#         return await self.execute(**kwargs)
+
+#     @abstractmethod
+#     async def execute(self, **kwargs) -> Any:
+#         """Execute the tool with given parameters."""
+
+#     def to_param(self) -> Dict:
+#         """Convert tool to function call format."""
+#         return {
+#             "type": "function",
+#             "function": {
+#                 "name": self.name,
+#                 "description": self.description,
+#                 "parameters": self.parameters,
+#             },
+#         }
+
+
+class ToolResult(BaseModel):
+    """Represents the result of a tool execution."""
+
+    output: Any = Field(default=None)
+    error: Optional[str] = Field(default=None)
+    base64_image: Optional[str] = Field(default=None)
+    system: Optional[str] = Field(default=None)
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __bool__(self):
+        return any(getattr(self, field) for field in self.__fields__)
+
+    def __add__(self, other: "ToolResult"):
+        def combine_fields(
+            field: Optional[str], other_field: Optional[str], concatenate: bool = True
+        ):
+            if field and other_field:
+                if concatenate:
+                    return field + other_field
+                raise ValueError("Cannot combine tool results")
+            return field or other_field
+
+        return ToolResult(
+            output=combine_fields(self.output, other.output),
+            error=combine_fields(self.error, other.error),
+            base64_image=combine_fields(self.base64_image, other.base64_image, False),
+            system=combine_fields(self.system, other.system),
+        )
+
+    def __str__(self):
+        return f"Error: {self.error}" if self.error else self.output
+
+    def replace(self, **kwargs):
+        """Returns a new ToolResult with the given fields replaced."""
+        # return self.copy(update=kwargs)
+        return type(self)(**{**self.dict(), **kwargs})
+
+
+class BaseTool(ABC, BaseModel):
+    """Consolidated base class for all tools combining BaseModel and Tool functionality.
+
+    Provides:
+    - Pydantic model validation
+    - Schema registration
+    - Standardized result handling
+    - Abstract execution interface
+
+    Attributes:
+        name (str): Tool name
+        description (str): Tool description
+        parameters (dict): Tool parameters schema
+        _schemas (Dict[str, List[ToolSchema]]): Registered method schemas
+    """
+
+    name: str
+    description: str
+    parameters: Optional[dict] = None
+    # _schemas: Dict[str, List[ToolSchema]] = {}
+
+    class Config:
+        arbitrary_types_allowed = True
+        underscore_attrs_are_private = False
+
+    # def __init__(self, **data):
+    #     """Initialize tool with model validation and schema registration."""
+    #     super().__init__(**data)
+    #     logger.debug(f"Initializing tool class: {self.__class__.__name__}")
+    #     self._register_schemas()
+
+    # def _register_schemas(self):
+    #     """Register schemas from all decorated methods."""
+    #     for name, method in inspect.getmembers(self, predicate=inspect.ismethod):
+    #         if hasattr(method, 'tool_schemas'):
+    #             self._schemas[name] = method.tool_schemas
+    #             logger.debug(f"Registered schemas for method '{name}' in {self.__class__.__name__}")
+
+    async def __call__(self, **kwargs) -> Any:
+        """Execute the tool with given parameters."""
+        return await self.execute(**kwargs)
+
+    @abstractmethod
+    async def execute(self, **kwargs) -> Any:
+        """Execute the tool with given parameters."""
+
+    def to_param(self) -> Dict:
+        """Convert tool to function call format.
+
+        Returns:
+            Dictionary with tool metadata in OpenAI function calling format
+        """
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.parameters,
+            },
+        }
+
+    # def get_schemas(self) -> Dict[str, List[ToolSchema]]:
+    #     """Get all registered tool schemas.
+
+    #     Returns:
+    #         Dict mapping method names to their schema definitions
+    #     """
+    #     return self._schemas
+
+    def success_response(self, data: Union[Dict[str, Any], str]) -> ToolResult:
+        """Create a successful tool result.
+
+        Args:
+            data: Result data (dictionary or string)
+
+        Returns:
+            ToolResult with success=True and formatted output
+        """
+        if isinstance(data, str):
+            text = data
+        else:
+            text = json.dumps(data, indent=2)
+        logger.debug(f"Created success response for {self.__class__.__name__}")
+        return ToolResult(output=text)
+
+    def fail_response(self, msg: str) -> ToolResult:
+        """Create a failed tool result.
+
+        Args:
+            msg: Error message describing the failure
+
+        Returns:
+            ToolResult with success=False and error message
+        """
+        logger.debug(f"Tool {self.__class__.__name__} returned failed result: {msg}")
+        return ToolResult(error=msg)
+
+
+class CLIResult(ToolResult):
+    """A ToolResult that can be rendered as a CLI output."""
+
+
+class ToolFailure(ToolResult):
+    """A ToolResult that represents a failure."""

app/tool/python_execute.py

@@ -0,0 +1,75 @@
+import multiprocessing
+import sys
+from io import StringIO
+from typing import Dict
+
+from app.tool.base import BaseTool
+
+
+class PythonExecute(BaseTool):
+    """A tool for executing Python code with timeout and safety restrictions."""
+
+    name: str = "python_execute"
+    description: str = "Executes Python code string. Note: Only print outputs are visible, function return values are not captured. Use print statements to see results."
+    parameters: dict = {
+        "type": "object",
+        "properties": {
+            "code": {
+                "type": "string",
+                "description": "The Python code to execute.",
+            },
+        },
+        "required": ["code"],
+    }
+
+    def _run_code(self, code: str, result_dict: dict, safe_globals: dict) -> None:
+        original_stdout = sys.stdout
+        try:
+            output_buffer = StringIO()
+            sys.stdout = output_buffer
+            exec(code, safe_globals, safe_globals)
+            result_dict["observation"] = output_buffer.getvalue()
+            result_dict["success"] = True
+        except Exception as e:
+            result_dict["observation"] = str(e)
+            result_dict["success"] = False
+        finally:
+            sys.stdout = original_stdout
+
+    async def execute(
+        self,
+        code: str,
+        timeout: int = 5,
+    ) -> Dict:
+        """
+        Executes the provided Python code with a timeout.
+
+        Args:
+            code (str): The Python code to execute.
+            timeout (int): Execution timeout in seconds.
+
+        Returns:
+            Dict: Contains 'output' with execution output or error message and 'success' status.
+        """
+
+        with multiprocessing.Manager() as manager:
+            result = manager.dict({"observation": "", "success": False})
+            if isinstance(__builtins__, dict):
+                safe_globals = {"__builtins__": __builtins__}
+            else:
+                safe_globals = {"__builtins__": __builtins__.__dict__.copy()}
+            proc = multiprocessing.Process(
+                target=self._run_code, args=(code, result, safe_globals)
+            )
+            proc.start()
+            proc.join(timeout)
+
+            # timeout process
+            if proc.is_alive():
+                proc.terminate()
+                proc.join(1)
+                return {
+                    "observation": f"Execution timeout after {timeout} seconds",
+                    "success": False,
+                }
+            return dict(result)

app/tool/str_replace_editor.py

@@ -0,0 +1,432 @@
+"""File and directory manipulation tool with sandbox support."""
+
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, DefaultDict, List, Literal, Optional, get_args
+
+from app.config import config
+from app.exceptions import ToolError
+from app.tool import BaseTool
+from app.tool.base import CLIResult, ToolResult
+from app.tool.file_operators import (
+    FileOperator,
+    LocalFileOperator,
+    PathLike,
+    SandboxFileOperator,
+)
+
+
+Command = Literal[
+    "view",
+    "create",
+    "str_replace",
+    "insert",
+    "undo_edit",
+]
+
+# Constants
+SNIPPET_LINES: int = 4
+MAX_RESPONSE_LEN: int = 16000
+TRUNCATED_MESSAGE: str = (
+    "<response clipped><NOTE>To save on context only part of this file has been shown to you. "
+    "You should retry this tool after you have searched inside the file with `grep -n` "
+    "in order to find the line numbers of what you are looking for.</NOTE>"
+)
+
+# Tool description
+_STR_REPLACE_EDITOR_DESCRIPTION = """Custom editing tool for viewing, creating and editing files
+* State is persistent across command calls and discussions with the user
+* If `path` is a file, `view` displays the result of applying `cat -n`. If `path` is a directory, `view` lists non-hidden files and directories up to 2 levels deep
+* The `create` command cannot be used if the specified `path` already exists as a file
+* If a `command` generates a long output, it will be truncated and marked with `<response clipped>`
+* The `undo_edit` command will revert the last edit made to the file at `path`
+
+Notes for using the `str_replace` command:
+* The `old_str` parameter should match EXACTLY one or more consecutive lines from the original file. Be mindful of whitespaces!
+* If the `old_str` parameter is not unique in the file, the replacement will not be performed. Make sure to include enough context in `old_str` to make it unique
+* The `new_str` parameter should contain the edited lines that should replace the `old_str`
+"""
+
+
+def maybe_truncate(
+    content: str, truncate_after: Optional[int] = MAX_RESPONSE_LEN
+) -> str:
+    """Truncate content and append a notice if content exceeds the specified length."""
+    if not truncate_after or len(content) <= truncate_after:
+        return content
+    return content[:truncate_after] + TRUNCATED_MESSAGE
+
+
+class StrReplaceEditor(BaseTool):
+    """A tool for viewing, creating, and editing files with sandbox support."""
+
+    name: str = "str_replace_editor"
+    description: str = _STR_REPLACE_EDITOR_DESCRIPTION
+    parameters: dict = {
+        "type": "object",
+        "properties": {
+            "command": {
+                "description": "The commands to run. Allowed options are: `view`, `create`, `str_replace`, `insert`, `undo_edit`.",
+                "enum": ["view", "create", "str_replace", "insert", "undo_edit"],
+                "type": "string",
+            },
+            "path": {
+                "description": "Absolute path to file or directory.",
+                "type": "string",
+            },
+            "file_text": {
+                "description": "Required parameter of `create` command, with the content of the file to be created.",
+                "type": "string",
+            },
+            "old_str": {
+                "description": "Required parameter of `str_replace` command containing the string in `path` to replace.",
+                "type": "string",
+            },
+            "new_str": {
+                "description": "Optional parameter of `str_replace` command containing the new string (if not given, no string will be added). Required parameter of `insert` command containing the string to insert.",
+                "type": "string",
+            },
+            "insert_line": {
+                "description": "Required parameter of `insert` command. The `new_str` will be inserted AFTER the line `insert_line` of `path`.",
+                "type": "integer",
+            },
+            "view_range": {
+                "description": "Optional parameter of `view` command when `path` points to a file. If none is given, the full file is shown. If provided, the file will be shown in the indicated line number range, e.g. [11, 12] will show lines 11 and 12. Indexing at 1 to start. Setting `[start_line, -1]` shows all lines from `start_line` to the end of the file.",
+                "items": {"type": "integer"},
+                "type": "array",
+            },
+        },
+        "required": ["command", "path"],
+    }
+    _file_history: DefaultDict[PathLike, List[str]] = defaultdict(list)
+    _local_operator: LocalFileOperator = LocalFileOperator()
+    _sandbox_operator: SandboxFileOperator = SandboxFileOperator()
+
+    # def _get_operator(self, use_sandbox: bool) -> FileOperator:
+    def _get_operator(self) -> FileOperator:
+        """Get the appropriate file operator based on execution mode."""
+        return (
+            self._sandbox_operator
+            if config.sandbox.use_sandbox
+            else self._local_operator
+        )
+
+    async def execute(
+        self,
+        *,
+        command: Command,
+        path: str,
+        file_text: str | None = None,
+        view_range: list[int] | None = None,
+        old_str: str | None = None,
+        new_str: str | None = None,
+        insert_line: int | None = None,
+        **kwargs: Any,
+    ) -> str:
+        """Execute a file operation command."""
+        # Get the appropriate file operator
+        operator = self._get_operator()
+
+        # Validate path and command combination
+        await self.validate_path(command, Path(path), operator)
+
+        # Execute the appropriate command
+        if command == "view":
+            result = await self.view(path, view_range, operator)
+        elif command == "create":
+            if file_text is None:
+                raise ToolError("Parameter `file_text` is required for command: create")
+            await operator.write_file(path, file_text)
+            self._file_history[path].append(file_text)
+            result = ToolResult(output=f"File created successfully at: {path}")
+        elif command == "str_replace":
+            if old_str is None:
+                raise ToolError(
+                    "Parameter `old_str` is required for command: str_replace"
+                )
+            result = await self.str_replace(path, old_str, new_str, operator)
+        elif command == "insert":
+            if insert_line is None:
+                raise ToolError(
+                    "Parameter `insert_line` is required for command: insert"
+                )
+            if new_str is None:
+                raise ToolError("Parameter `new_str` is required for command: insert")
+            result = await self.insert(path, insert_line, new_str, operator)
+        elif command == "undo_edit":
+            result = await self.undo_edit(path, operator)
+        else:
+            # This should be caught by type checking, but we include it for safety
+            raise ToolError(
+                f'Unrecognized command {command}. The allowed commands for the {self.name} tool are: {", ".join(get_args(Command))}'
+            )
+
+        return str(result)
+
+    async def validate_path(
+        self, command: str, path: Path, operator: FileOperator
+    ) -> None:
+        """Validate path and command combination based on execution environment."""
+        # Check if path is absolute
+        if not path.is_absolute():
+            raise ToolError(f"The path {path} is not an absolute path")
+
+        # Only check if path exists for non-create commands
+        if command != "create":
+            if not await operator.exists(path):
+                raise ToolError(
+                    f"The path {path} does not exist. Please provide a valid path."
+                )
+
+            # Check if path is a directory
+            is_dir = await operator.is_directory(path)
+            if is_dir and command != "view":
+                raise ToolError(
+                    f"The path {path} is a directory and only the `view` command can be used on directories"
+                )
+
+        # Check if file exists for create command
+        elif command == "create":
+            exists = await operator.exists(path)
+            if exists:
+                raise ToolError(
+                    f"File already exists at: {path}. Cannot overwrite files using command `create`."
+                )
+
+    async def view(
+        self,
+        path: PathLike,
+        view_range: Optional[List[int]] = None,
+        operator: FileOperator = None,
+    ) -> CLIResult:
+        """Display file or directory content."""
+        # Determine if path is a directory
+        is_dir = await operator.is_directory(path)
+
+        if is_dir:
+            # Directory handling
+            if view_range:
+                raise ToolError(
+                    "The `view_range` parameter is not allowed when `path` points to a directory."
+                )
+
+            return await self._view_directory(path, operator)
+        else:
+            # File handling
+            return await self._view_file(path, operator, view_range)
+
+    @staticmethod
+    async def _view_directory(path: PathLike, operator: FileOperator) -> CLIResult:
+        """Display directory contents."""
+        find_cmd = f"find {path} -maxdepth 2 -not -path '*/\\.*'"
+
+        # Execute command using the operator
+        returncode, stdout, stderr = await operator.run_command(find_cmd)
+
+        if not stderr:
+            stdout = (
+                f"Here's the files and directories up to 2 levels deep in {path}, "
+                f"excluding hidden items:\n{stdout}\n"
+            )
+
+        return CLIResult(output=stdout, error=stderr)
+
+    async def _view_file(
+        self,
+        path: PathLike,
+        operator: FileOperator,
+        view_range: Optional[List[int]] = None,
+    ) -> CLIResult:
+        """Display file content, optionally within a specified line range."""
+        # Read file content
+        file_content = await operator.read_file(path)
+        init_line = 1
+
+        # Apply view range if specified
+        if view_range:
+            if len(view_range) != 2 or not all(isinstance(i, int) for i in view_range):
+                raise ToolError(
+                    "Invalid `view_range`. It should be a list of two integers."
+                )
+
+            file_lines = file_content.split("\n")
+            n_lines_file = len(file_lines)
+            init_line, final_line = view_range
+
+            # Validate view range
+            if init_line < 1 or init_line > n_lines_file:
+                raise ToolError(
+                    f"Invalid `view_range`: {view_range}. Its first element `{init_line}` should be "
+                    f"within the range of lines of the file: {[1, n_lines_file]}"
+                )
+            if final_line > n_lines_file:
+                raise ToolError(
+                    f"Invalid `view_range`: {view_range}. Its second element `{final_line}` should be "
+                    f"smaller than the number of lines in the file: `{n_lines_file}`"
+                )
+            if final_line != -1 and final_line < init_line:
+                raise ToolError(
+                    f"Invalid `view_range`: {view_range}. Its second element `{final_line}` should be "
+                    f"larger or equal than its first `{init_line}`"
+                )
+
+            # Apply range
+            if final_line == -1:
+                file_content = "\n".join(file_lines[init_line - 1 :])
+            else:
+                file_content = "\n".join(file_lines[init_line - 1 : final_line])
+
+        # Format and return result
+        return CLIResult(
+            output=self._make_output(file_content, str(path), init_line=init_line)
+        )
+
+    async def str_replace(
+        self,
+        path: PathLike,
+        old_str: str,
+        new_str: Optional[str] = None,
+        operator: FileOperator = None,
+    ) -> CLIResult:
+        """Replace a unique string in a file with a new string."""
+        # Read file content and expand tabs
+        file_content = (await operator.read_file(path)).expandtabs()
+        old_str = old_str.expandtabs()
+        new_str = new_str.expandtabs() if new_str is not None else ""
+
+        # Check if old_str is unique in the file
+        occurrences = file_content.count(old_str)
+        if occurrences == 0:
+            raise ToolError(
+                f"No replacement was performed, old_str `{old_str}` did not appear verbatim in {path}."
+            )
+        elif occurrences > 1:
+            # Find line numbers of occurrences
+            file_content_lines = file_content.split("\n")
+            lines = [
+                idx + 1
+                for idx, line in enumerate(file_content_lines)
+                if old_str in line
+            ]
+            raise ToolError(
+                f"No replacement was performed. Multiple occurrences of old_str `{old_str}` "
+                f"in lines {lines}. Please ensure it is unique"
+            )
+
+        # Replace old_str with new_str
+        new_file_content = file_content.replace(old_str, new_str)
+
+        # Write the new content to the file
+        await operator.write_file(path, new_file_content)
+
+        # Save the original content to history
+        self._file_history[path].append(file_content)
+
+        # Create a snippet of the edited section
+        replacement_line = file_content.split(old_str)[0].count("\n")
+        start_line = max(0, replacement_line - SNIPPET_LINES)
+        end_line = replacement_line + SNIPPET_LINES + new_str.count("\n")
+        snippet = "\n".join(new_file_content.split("\n")[start_line : end_line + 1])
+
+        # Prepare the success message
+        success_msg = f"The file {path} has been edited. "
+        success_msg += self._make_output(
+            snippet, f"a snippet of {path}", start_line + 1
+        )
+        success_msg += "Review the changes and make sure they are as expected. Edit the file again if necessary."
+
+        return CLIResult(output=success_msg)
+
+    async def insert(
+        self,
+        path: PathLike,
+        insert_line: int,
+        new_str: str,
+        operator: FileOperator = None,
+    ) -> CLIResult:
+        """Insert text at a specific line in a file."""
+        # Read and prepare content
+        file_text = (await operator.read_file(path)).expandtabs()
+        new_str = new_str.expandtabs()
+        file_text_lines = file_text.split("\n")
+        n_lines_file = len(file_text_lines)
+
+        # Validate insert_line
+        if insert_line < 0 or insert_line > n_lines_file:
+            raise ToolError(
+                f"Invalid `insert_line` parameter: {insert_line}. It should be within "
+                f"the range of lines of the file: {[0, n_lines_file]}"
+            )
+
+        # Perform insertion
+        new_str_lines = new_str.split("\n")
+        new_file_text_lines = (
+            file_text_lines[:insert_line]
+            + new_str_lines
+            + file_text_lines[insert_line:]
+        )
+
+        # Create a snippet for preview
+        snippet_lines = (
+            file_text_lines[max(0, insert_line - SNIPPET_LINES) : insert_line]
+            + new_str_lines
+            + file_text_lines[insert_line : insert_line + SNIPPET_LINES]
+        )
+
+        # Join lines and write to file
+        new_file_text = "\n".join(new_file_text_lines)
+        snippet = "\n".join(snippet_lines)
+
+        await operator.write_file(path, new_file_text)
+        self._file_history[path].append(file_text)
+
+        # Prepare success message
+        success_msg = f"The file {path} has been edited. "
+        success_msg += self._make_output(
+            snippet,
+            "a snippet of the edited file",
+            max(1, insert_line - SNIPPET_LINES + 1),
+        )
+        success_msg += "Review the changes and make sure they are as expected (correct indentation, no duplicate lines, etc). Edit the file again if necessary."
+
+        return CLIResult(output=success_msg)
+
+    async def undo_edit(
+        self, path: PathLike, operator: FileOperator = None
+    ) -> CLIResult:
+        """Revert the last edit made to a file."""
+        if not self._file_history[path]:
+            raise ToolError(f"No edit history found for {path}.")
+
+        old_text = self._file_history[path].pop()
+        await operator.write_file(path, old_text)
+
+        return CLIResult(
+            output=f"Last edit to {path} undone successfully. {self._make_output(old_text, str(path))}"
+        )
+
+    def _make_output(
+        self,
+        file_content: str,
+        file_descriptor: str,
+        init_line: int = 1,
+        expand_tabs: bool = True,
+    ) -> str:
+        """Format file content for display with line numbers."""
+        file_content = maybe_truncate(file_content)
+        if expand_tabs:
+            file_content = file_content.expandtabs()
+
+        # Add line numbers to each line
+        file_content = "\n".join(
+            [
+                f"{i + init_line:6}\t{line}"
+                for i, line in enumerate(file_content.split("\n"))
+            ]
+        )
+
+        return (
+            f"Here's the result of running `cat -n` on {file_descriptor}:\n"
+            + file_content
+            + "\n"
+        )

app/tool/terminate.py

@@ -0,0 +1,25 @@
+from app.tool.base import BaseTool
+
+
+_TERMINATE_DESCRIPTION = """Terminate the interaction when the request is met OR if the assistant cannot proceed further with the task.
+When you have finished all the tasks, call this tool to end the work."""
+
+
+class Terminate(BaseTool):
+    name: str = "terminate"
+    description: str = _TERMINATE_DESCRIPTION
+    parameters: dict = {
+        "type": "object",
+        "properties": {
+            "status": {
+                "type": "string",
+                "description": "The finish status of the interaction.",
+                "enum": ["success", "failure"],
+            }
+        },
+        "required": ["status"],
+    }
+
+    async def execute(self, status: str) -> str:
+        """Finish the current execution"""
+        return f"The interaction has been completed with status: {status}"

app/tool/tool_collection.py

@@ -0,0 +1,71 @@
+"""Collection classes for managing multiple tools."""
+from typing import Any, Dict, List
+
+from app.exceptions import ToolError
+from app.logger import logger
+from app.tool.base import BaseTool, ToolFailure, ToolResult
+
+
+class ToolCollection:
+    """A collection of defined tools."""
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __init__(self, *tools: BaseTool):
+        self.tools = tools
+        self.tool_map = {tool.name: tool for tool in tools}
+
+    def __iter__(self):
+        return iter(self.tools)
+
+    def to_params(self) -> List[Dict[str, Any]]:
+        return [tool.to_param() for tool in self.tools]
+
+    async def execute(
+        self, *, name: str, tool_input: Dict[str, Any] = None
+    ) -> ToolResult:
+        tool = self.tool_map.get(name)
+        if not tool:
+            return ToolFailure(error=f"Tool {name} is invalid")
+        try:
+            result = await tool(**tool_input)
+            return result
+        except ToolError as e:
+            return ToolFailure(error=e.message)
+
+    async def execute_all(self) -> List[ToolResult]:
+        """Execute all tools in the collection sequentially."""
+        results = []
+        for tool in self.tools:
+            try:
+                result = await tool()
+                results.append(result)
+            except ToolError as e:
+                results.append(ToolFailure(error=e.message))
+        return results
+
+    def get_tool(self, name: str) -> BaseTool:
+        return self.tool_map.get(name)
+
+    def add_tool(self, tool: BaseTool):
+        """Add a single tool to the collection.
+
+        If a tool with the same name already exists, it will be skipped and a warning will be logged.
+        """
+        if tool.name in self.tool_map:
+            logger.warning(f"Tool {tool.name} already exists in collection, skipping")
+            return self
+
+        self.tools += (tool,)
+        self.tool_map[tool.name] = tool
+        return self
+
+    def add_tools(self, *tools: BaseTool):
+        """Add multiple tools to the collection.
+
+        If any tool has a name conflict with an existing tool, it will be skipped and a warning will be logged.
+        """
+        for tool in tools:
+            self.add_tool(tool)
+        return self

app/utils/__init__.py

@@ -0,0 +1 @@
+# Utility functions and constants for agent tools

app/utils/logger.py

@@ -0,0 +1,32 @@
+import logging
+import os
+
+import structlog
+
+
+ENV_MODE = os.getenv("ENV_MODE", "LOCAL")
+
+renderer = [structlog.processors.JSONRenderer()]
+if ENV_MODE.lower() == "local".lower():
+    renderer = [structlog.dev.ConsoleRenderer()]
+
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.PositionalArgumentsFormatter(),
+        structlog.processors.dict_tracebacks,
+        structlog.processors.CallsiteParameterAdder(
+            {
+                structlog.processors.CallsiteParameter.FILENAME,
+                structlog.processors.CallsiteParameter.FUNC_NAME,
+                structlog.processors.CallsiteParameter.LINENO,
+            }
+        ),
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.contextvars.merge_contextvars,
+        *renderer,
+    ],
+    cache_logger_on_first_use=True,
+)
+
+logger: structlog.stdlib.BoundLogger = structlog.get_logger(level=logging.DEBUG)

app_complete.py

@@ -0,0 +1,715 @@
+import gradio as gr
+import os
+import json
+import sqlite3
+import hashlib
+import datetime
+from pathlib import Path
+
+# Cloudflare configuration
+CLOUDFLARE_CONFIG = {
+    "api_token": os.getenv("CLOUDFLARE_API_TOKEN", ""),
+    "account_id": os.getenv("CLOUDFLARE_ACCOUNT_ID", ""),
+    "d1_database_id": os.getenv("CLOUDFLARE_D1_DATABASE_ID", ""),
+    "r2_bucket_name": os.getenv("CLOUDFLARE_R2_BUCKET_NAME", ""),
+    "kv_namespace_id": os.getenv("CLOUDFLARE_KV_NAMESPACE_ID", ""),
+    "durable_objects_id": os.getenv("CLOUDFLARE_DURABLE_OBJECTS_ID", ""),
+}
+
+# AI Model Categories with 200+ models
+AI_MODELS = {
+    "Text Generation": {
+        "Qwen Models": [
+            "Qwen/Qwen2.5-72B-Instruct",
+            "Qwen/Qwen2.5-32B-Instruct",
+            "Qwen/Qwen2.5-14B-Instruct",
+            "Qwen/Qwen2.5-7B-Instruct",
+            "Qwen/Qwen2.5-3B-Instruct",
+            "Qwen/Qwen2.5-1.5B-Instruct",
+            "Qwen/Qwen2.5-0.5B-Instruct",
+            "Qwen/Qwen2-72B-Instruct",
+            "Qwen/Qwen2-57B-A14B-Instruct",
+            "Qwen/Qwen2-7B-Instruct",
+            "Qwen/Qwen2-1.5B-Instruct",
+            "Qwen/Qwen2-0.5B-Instruct",
+            "Qwen/Qwen1.5-110B-Chat",
+            "Qwen/Qwen1.5-72B-Chat",
+            "Qwen/Qwen1.5-32B-Chat",
+            "Qwen/Qwen1.5-14B-Chat",
+            "Qwen/Qwen1.5-7B-Chat",
+            "Qwen/Qwen1.5-4B-Chat",
+            "Qwen/Qwen1.5-1.8B-Chat",
+            "Qwen/Qwen1.5-0.5B-Chat",
+            "Qwen/CodeQwen1.5-7B-Chat",
+            "Qwen/Qwen2.5-Math-72B-Instruct",
+            "Qwen/Qwen2.5-Math-7B-Instruct",
+            "Qwen/Qwen2.5-Coder-32B-Instruct",
+            "Qwen/Qwen2.5-Coder-14B-Instruct",
+            "Qwen/Qwen2.5-Coder-7B-Instruct",
+            "Qwen/Qwen2.5-Coder-3B-Instruct",
+            "Qwen/Qwen2.5-Coder-1.5B-Instruct",
+            "Qwen/Qwen2.5-Coder-0.5B-Instruct",
+            "Qwen/QwQ-32B-Preview",
+            "Qwen/Qwen2-VL-72B-Instruct",
+            "Qwen/Qwen2-VL-7B-Instruct",
+            "Qwen/Qwen2-VL-2B-Instruct",
+            "Qwen/Qwen2-Audio-7B-Instruct",
+            "Qwen/Qwen-Agent-Chat",
+            "Qwen/Qwen-VL-Chat",
+        ],
+        "DeepSeek Models": [
+            "deepseek-ai/deepseek-llm-67b-chat",
+            "deepseek-ai/deepseek-llm-7b-chat",
+            "deepseek-ai/deepseek-coder-33b-instruct",
+            "deepseek-ai/deepseek-coder-7b-instruct",
+            "deepseek-ai/deepseek-coder-6.7b-instruct",
+            "deepseek-ai/deepseek-coder-1.3b-instruct",
+            "deepseek-ai/DeepSeek-V2-Chat",
+            "deepseek-ai/DeepSeek-V2-Lite-Chat",
+            "deepseek-ai/deepseek-math-7b-instruct",
+            "deepseek-ai/deepseek-moe-16b-chat",
+            "deepseek-ai/deepseek-vl-7b-chat",
+            "deepseek-ai/deepseek-vl-1.3b-chat",
+            "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
+            "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B",
+            "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
+            "deepseek-ai/DeepSeek-R1-Distill-Llama-8B",
+            "deepseek-ai/DeepSeek-Reasoner-R1",
+        ],
+    },
+    "Image Processing": {
+        "Image Generation": [
+            "black-forest-labs/FLUX.1-dev",
+            "black-forest-labs/FLUX.1-schnell",
+            "black-forest-labs/FLUX.1-pro",
+            "runwayml/stable-diffusion-v1-5",
+            "stabilityai/stable-diffusion-xl-base-1.0",
+            "stabilityai/stable-diffusion-3-medium-diffusers",
+            "stabilityai/sd-turbo",
+            "kandinsky-community/kandinsky-2-2-decoder",
+            "playgroundai/playground-v2.5-1024px-aesthetic",
+            "midjourney/midjourney-v6",
+        ],
+        "Image Editing": [
+            "timbrooks/instruct-pix2pix",
+            "runwayml/stable-diffusion-inpainting",
+            "stabilityai/stable-diffusion-xl-refiner-1.0",
+            "lllyasviel/control_v11p_sd15_inpaint",
+            "SG161222/RealVisXL_V4.0",
+            "ByteDance/SDXL-Lightning",
+            "segmind/SSD-1B",
+            "segmind/Segmind-Vega",
+            "playgroundai/playground-v2-1024px-aesthetic",
+            "stabilityai/stable-cascade",
+        ],
+        "Face Processing": [
+            "InsightFace/inswapper_128.onnx",
+            "deepinsight/insightface",
+            "TencentARC/GFPGAN",
+            "sczhou/CodeFormer",
+            "xinntao/Real-ESRGAN",
+            "ESRGAN/ESRGAN",
+        ],
+    },
+    "Audio Processing": {
+        "Text-to-Speech": [
+            "microsoft/speecht5_tts",
+            "facebook/mms-tts-eng",
+            "facebook/mms-tts-ara",
+            "coqui/XTTS-v2",
+            "suno/bark",
+            "parler-tts/parler-tts-large-v1",
+            "microsoft/DisTTS",
+            "facebook/fastspeech2-en-ljspeech",
+            "espnet/kan-bayashi_ljspeech_vits",
+            "facebook/tts_transformer-en-ljspeech",
+            "microsoft/SpeechT5",
+            "Voicemod/fastspeech2-en-male1",
+            "facebook/mms-tts-spa",
+            "facebook/mms-tts-fra",
+            "facebook/mms-tts-deu",
+        ],
+        "Speech-to-Text": [
+            "openai/whisper-large-v3",
+            "openai/whisper-large-v2",
+            "openai/whisper-medium",
+            "openai/whisper-small",
+            "openai/whisper-base",
+            "openai/whisper-tiny",
+            "facebook/wav2vec2-large-960h",
+            "facebook/wav2vec2-base-960h",
+            "microsoft/unispeech-sat-large",
+            "nvidia/stt_en_conformer_ctc_large",
+            "speechbrain/asr-wav2vec2-commonvoice-en",
+            "facebook/mms-1b-all",
+            "facebook/seamless-m4t-v2-large",
+            "distil-whisper/distil-large-v3",
+            "distil-whisper/distil-medium.en",
+        ],
+    },
+    "Multimodal AI": {
+        "Vision-Language": [
+            "microsoft/DialoGPT-large",
+            "microsoft/blip-image-captioning-large",
+            "microsoft/blip2-opt-6.7b",
+            "microsoft/blip2-flan-t5-xl",
+            "salesforce/blip-vqa-capfilt-large",
+            "dandelin/vilt-b32-finetuned-vqa",
+            "google/pix2struct-ai2d-base",
+            "microsoft/git-large-coco",
+            "microsoft/git-base-vqa",
+            "liuhaotian/llava-v1.6-34b",
+            "liuhaotian/llava-v1.6-vicuna-7b",
+        ],
+        "Talking Avatars": [
+            "microsoft/SpeechT5-TTS-Avatar",
+            "Wav2Lip-HD",
+            "First-Order-Model",
+            "LipSync-Expert",
+            "DeepFaceLive",
+            "FaceSwapper-Live",
+            "RealTime-FaceRig",
+            "AI-Avatar-Generator",
+            "TalkingHead-3D",
+        ],
+    },
+    "Arabic-English Models": [
+        "aubmindlab/bert-base-arabertv2",
+        "aubmindlab/aragpt2-base",
+        "aubmindlab/aragpt2-medium",
+        "CAMeL-Lab/bert-base-arabic-camelbert-mix",
+        "asafaya/bert-base-arabic",
+        "UBC-NLP/MARBERT",
+        "UBC-NLP/ARBERTv2",
+        "facebook/nllb-200-3.3B",
+        "facebook/m2m100_1.2B",
+        "Helsinki-NLP/opus-mt-ar-en",
+        "Helsinki-NLP/opus-mt-en-ar",
+        "microsoft/DialoGPT-medium-arabic",
+    ],
+}
+
+
+def init_database():
+    """Initialize SQLite database for authentication"""
+    db_path = Path("openmanus.db")
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+
+    # Create users table
+    cursor.execute(
+        """
+    CREATE TABLE IF NOT EXISTS users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        mobile_number TEXT UNIQUE NOT NULL,
+        full_name TEXT NOT NULL,
+        password_hash TEXT NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        last_login TIMESTAMP,
+        is_active BOOLEAN DEFAULT 1
+    )
+    """
+    )
+
+    # Create sessions table
+    cursor.execute(
+        """
+    CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        user_id INTEGER NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        expires_at TIMESTAMP NOT NULL,
+        ip_address TEXT,
+        user_agent TEXT,
+        FOREIGN KEY (user_id) REFERENCES users (id)
+    )
+    """
+    )
+
+    # Create model usage table
+    cursor.execute(
+        """
+    CREATE TABLE IF NOT EXISTS model_usage (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id INTEGER,
+        model_name TEXT NOT NULL,
+        category TEXT NOT NULL,
+        input_text TEXT,
+        output_text TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        processing_time REAL,
+        FOREIGN KEY (user_id) REFERENCES users (id)
+    )
+    """
+    )
+
+    conn.commit()
+    conn.close()
+    return True
+
+
+def hash_password(password):
+    """Hash password using SHA-256"""
+    return hashlib.sha256(password.encode()).hexdigest()
+
+
+def signup_user(mobile, name, password, confirm_password):
+    """User registration with mobile number"""
+    if not all([mobile, name, password, confirm_password]):
+        return "❌ Please fill in all fields"
+
+    if password != confirm_password:
+        return "❌ Passwords do not match"
+
+    if len(password) < 6:
+        return "❌ Password must be at least 6 characters"
+
+    # Validate mobile number
+    if not mobile.replace("+", "").replace("-", "").replace(" ", "").isdigit():
+        return "❌ Please enter a valid mobile number"
+
+    try:
+        conn = sqlite3.connect("openmanus.db")
+        cursor = conn.cursor()
+
+        # Check if mobile number already exists
+        cursor.execute("SELECT id FROM users WHERE mobile_number = ?", (mobile,))
+        if cursor.fetchone():
+            conn.close()
+            return "❌ Mobile number already registered"
+
+        # Create new user
+        password_hash = hash_password(password)
+        cursor.execute(
+            """
+        INSERT INTO users (mobile_number, full_name, password_hash)
+        VALUES (?, ?, ?)
+        """,
+            (mobile, name, password_hash),
+        )
+
+        conn.commit()
+        conn.close()
+
+        return f"✅ Account created successfully for {name}! Welcome to OpenManus Platform."
+
+    except Exception as e:
+        return f"❌ Registration failed: {str(e)}"
+
+
+def login_user(mobile, password):
+    """User authentication"""
+    if not mobile or not password:
+        return "❌ Please provide mobile number and password"
+
+    try:
+        conn = sqlite3.connect("openmanus.db")
+        cursor = conn.cursor()
+
+        # Verify credentials
+        password_hash = hash_password(password)
+        cursor.execute(
+            """
+        SELECT id, full_name FROM users
+        WHERE mobile_number = ? AND password_hash = ? AND is_active = 1
+        """,
+            (mobile, password_hash),
+        )
+
+        user = cursor.fetchone()
+        if user:
+            # Update last login
+            cursor.execute(
+                """
+            UPDATE users SET last_login = CURRENT_TIMESTAMP WHERE id = ?
+            """,
+                (user[0],),
+            )
+            conn.commit()
+            conn.close()
+
+            return f"✅ Welcome back, {user[1]}! Login successful."
+        else:
+            conn.close()
+            return "❌ Invalid mobile number or password"
+
+    except Exception as e:
+        return f"❌ Login failed: {str(e)}"
+
+
+def use_ai_model(model_name, input_text, user_session="guest"):
+    """Simulate AI model usage"""
+    if not input_text.strip():
+        return "Please enter some text for the AI model to process."
+
+    # Simulate model processing
+    response_templates = {
+        "text": f"🧠 {model_name} processed: '{input_text}'\n\n✨ AI Response: This is a simulated response from the {model_name} model. In production, this would connect to the actual model API.",
+        "image": f"🖼️ {model_name} would generate/edit an image based on: '{input_text}'\n\n📸 Output: Image processing complete (simulated)",
+        "audio": f"🎵 {model_name} audio processing for: '{input_text}'\n\n🔊 Output: Audio generated/processed (simulated)",
+        "multimodal": f"🤖 {model_name} multimodal processing: '{input_text}'\n\n🎯 Output: Combined AI analysis complete (simulated)",
+    }
+
+    # Determine response type based on model
+    if any(
+        x in model_name.lower()
+        for x in ["image", "flux", "diffusion", "face", "avatar"]
+    ):
+        response_type = "image"
+    elif any(
+        x in model_name.lower()
+        for x in ["tts", "speech", "audio", "whisper", "wav2vec"]
+    ):
+        response_type = "audio"
+    elif any(x in model_name.lower() for x in ["vl", "blip", "vision", "talking"]):
+        response_type = "multimodal"
+    else:
+        response_type = "text"
+
+    return response_templates[response_type]
+
+
+def get_cloudflare_status():
+    """Get Cloudflare services status"""
+    services = []
+
+    if CLOUDFLARE_CONFIG["d1_database_id"]:
+        services.append("✅ D1 Database Connected")
+    else:
+        services.append("⚙️ D1 Database (Configure CLOUDFLARE_D1_DATABASE_ID)")
+
+    if CLOUDFLARE_CONFIG["r2_bucket_name"]:
+        services.append("✅ R2 Storage Connected")
+    else:
+        services.append("⚙️ R2 Storage (Configure CLOUDFLARE_R2_BUCKET_NAME)")
+
+    if CLOUDFLARE_CONFIG["kv_namespace_id"]:
+        services.append("✅ KV Cache Connected")
+    else:
+        services.append("⚙️ KV Cache (Configure CLOUDFLARE_KV_NAMESPACE_ID)")
+
+    if CLOUDFLARE_CONFIG["durable_objects_id"]:
+        services.append("✅ Durable Objects Connected")
+    else:
+        services.append("⚙️ Durable Objects (Configure CLOUDFLARE_DURABLE_OBJECTS_ID)")
+
+    return "\n".join(services)
+
+
+# Initialize database
+init_database()
+
+# Create Gradio interface
+with gr.Blocks(
+    title="OpenManus - Complete AI Platform",
+    theme=gr.themes.Soft(),
+    css="""
+    .container { max-width: 1400px; margin: 0 auto; }
+    .header { text-align: center; padding: 25px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 15px; margin-bottom: 25px; }
+    .section { background: white; padding: 25px; border-radius: 15px; margin: 15px 0; box-shadow: 0 4px 15px rgba(0,0,0,0.1); }
+    """,
+) as app:
+
+    # Header
+    gr.HTML(
+        """
+    <div class="header">
+        <h1>🤖 OpenManus - Complete AI Platform</h1>
+        <p><strong>Mobile Authentication + 200+ AI Models + Cloudflare Services</strong></p>
+        <p>🧠 Qwen & DeepSeek | 🖼️ Image Processing | 🎵 TTS/STT | 👤 Face Swap | 🌍 Arabic-English | ☁️ Cloud Integration</p>
+    </div>
+    """
+    )
+
+    with gr.Row():
+        # Authentication Section
+        with gr.Column(scale=1, elem_classes="section"):
+            gr.Markdown("## 🔐 Authentication System")
+
+            with gr.Tab("Sign Up"):
+                gr.Markdown("### Create New Account")
+                signup_mobile = gr.Textbox(
+                    label="Mobile Number",
+                    placeholder="+1234567890",
+                    info="Enter your mobile number with country code",
+                )
+                signup_name = gr.Textbox(
+                    label="Full Name", placeholder="Your full name"
+                )
+                signup_password = gr.Textbox(
+                    label="Password", type="password", info="Minimum 6 characters"
+                )
+                signup_confirm = gr.Textbox(label="Confirm Password", type="password")
+                signup_btn = gr.Button("Create Account", variant="primary")
+                signup_result = gr.Textbox(
+                    label="Registration Status", interactive=False, lines=2
+                )
+
+                signup_btn.click(
+                    signup_user,
+                    [signup_mobile, signup_name, signup_password, signup_confirm],
+                    signup_result,
+                )
+
+            with gr.Tab("Login"):
+                gr.Markdown("### Access Your Account")
+                login_mobile = gr.Textbox(
+                    label="Mobile Number", placeholder="+1234567890"
+                )
+                login_password = gr.Textbox(label="Password", type="password")
+                login_btn = gr.Button("Login", variant="primary")
+                login_result = gr.Textbox(
+                    label="Login Status", interactive=False, lines=2
+                )
+
+                login_btn.click(
+                    login_user, [login_mobile, login_password], login_result
+                )
+
+        # AI Models Section
+        with gr.Column(scale=2, elem_classes="section"):
+            gr.Markdown("## 🤖 AI Models Hub (200+ Models)")
+
+            with gr.Tab("Text Generation"):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Qwen Models (35 models)")
+                        qwen_model = gr.Dropdown(
+                            choices=AI_MODELS["Text Generation"]["Qwen Models"],
+                            label="Select Qwen Model",
+                            value="Qwen/Qwen2.5-72B-Instruct",
+                        )
+                        qwen_input = gr.Textbox(
+                            label="Input Text",
+                            placeholder="Enter your prompt for Qwen...",
+                            lines=3,
+                        )
+                        qwen_btn = gr.Button("Generate with Qwen")
+                        qwen_output = gr.Textbox(
+                            label="Qwen Response", lines=5, interactive=False
+                        )
+                        qwen_btn.click(
+                            use_ai_model, [qwen_model, qwen_input], qwen_output
+                        )
+
+                    with gr.Column():
+                        gr.Markdown("### DeepSeek Models (17 models)")
+                        deepseek_model = gr.Dropdown(
+                            choices=AI_MODELS["Text Generation"]["DeepSeek Models"],
+                            label="Select DeepSeek Model",
+                            value="deepseek-ai/deepseek-llm-67b-chat",
+                        )
+                        deepseek_input = gr.Textbox(
+                            label="Input Text",
+                            placeholder="Enter your prompt for DeepSeek...",
+                            lines=3,
+                        )
+                        deepseek_btn = gr.Button("Generate with DeepSeek")
+                        deepseek_output = gr.Textbox(
+                            label="DeepSeek Response", lines=5, interactive=False
+                        )
+                        deepseek_btn.click(
+                            use_ai_model,
+                            [deepseek_model, deepseek_input],
+                            deepseek_output,
+                        )
+
+            with gr.Tab("Image Processing"):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Image Generation")
+                        img_gen_model = gr.Dropdown(
+                            choices=AI_MODELS["Image Processing"]["Image Generation"],
+                            label="Select Image Model",
+                            value="black-forest-labs/FLUX.1-dev",
+                        )
+                        img_prompt = gr.Textbox(
+                            label="Image Prompt",
+                            placeholder="Describe the image you want to generate...",
+                            lines=2,
+                        )
+                        img_gen_btn = gr.Button("Generate Image")
+                        img_gen_output = gr.Textbox(
+                            label="Generation Status", lines=4, interactive=False
+                        )
+                        img_gen_btn.click(
+                            use_ai_model, [img_gen_model, img_prompt], img_gen_output
+                        )
+
+                    with gr.Column():
+                        gr.Markdown("### Face Processing & Editing")
+                        face_model = gr.Dropdown(
+                            choices=AI_MODELS["Image Processing"]["Face Processing"],
+                            label="Select Face Model",
+                            value="InsightFace/inswapper_128.onnx",
+                        )
+                        face_input = gr.Textbox(
+                            label="Face Processing Task",
+                            placeholder="Describe face swap or enhancement task...",
+                            lines=2,
+                        )
+                        face_btn = gr.Button("Process Face")
+                        face_output = gr.Textbox(
+                            label="Processing Status", lines=4, interactive=False
+                        )
+                        face_btn.click(
+                            use_ai_model, [face_model, face_input], face_output
+                        )
+
+            with gr.Tab("Audio Processing"):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Text-to-Speech (15 models)")
+                        tts_model = gr.Dropdown(
+                            choices=AI_MODELS["Audio Processing"]["Text-to-Speech"],
+                            label="Select TTS Model",
+                            value="microsoft/speecht5_tts",
+                        )
+                        tts_text = gr.Textbox(
+                            label="Text to Speak",
+                            placeholder="Enter text to convert to speech...",
+                            lines=3,
+                        )
+                        tts_btn = gr.Button("Generate Speech")
+                        tts_output = gr.Textbox(
+                            label="TTS Status", lines=4, interactive=False
+                        )
+                        tts_btn.click(use_ai_model, [tts_model, tts_text], tts_output)
+
+                    with gr.Column():
+                        gr.Markdown("### Speech-to-Text (15 models)")
+                        stt_model = gr.Dropdown(
+                            choices=AI_MODELS["Audio Processing"]["Speech-to-Text"],
+                            label="Select STT Model",
+                            value="openai/whisper-large-v3",
+                        )
+                        stt_input = gr.Textbox(
+                            label="Audio Description",
+                            placeholder="Describe audio file to transcribe...",
+                            lines=3,
+                        )
+                        stt_btn = gr.Button("Transcribe Audio")
+                        stt_output = gr.Textbox(
+                            label="STT Status", lines=4, interactive=False
+                        )
+                        stt_btn.click(use_ai_model, [stt_model, stt_input], stt_output)
+
+            with gr.Tab("Multimodal & Avatars"):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Vision-Language Models")
+                        vl_model = gr.Dropdown(
+                            choices=AI_MODELS["Multimodal AI"]["Vision-Language"],
+                            label="Select VL Model",
+                            value="liuhaotian/llava-v1.6-34b",
+                        )
+                        vl_input = gr.Textbox(
+                            label="Vision-Language Task",
+                            placeholder="Describe image analysis or VQA task...",
+                            lines=3,
+                        )
+                        vl_btn = gr.Button("Process with VL Model")
+                        vl_output = gr.Textbox(
+                            label="VL Response", lines=4, interactive=False
+                        )
+                        vl_btn.click(use_ai_model, [vl_model, vl_input], vl_output)
+
+                    with gr.Column():
+                        gr.Markdown("### Talking Avatars")
+                        avatar_model = gr.Dropdown(
+                            choices=AI_MODELS["Multimodal AI"]["Talking Avatars"],
+                            label="Select Avatar Model",
+                            value="Wav2Lip-HD",
+                        )
+                        avatar_input = gr.Textbox(
+                            label="Avatar Generation Task",
+                            placeholder="Describe talking avatar or lip-sync task...",
+                            lines=3,
+                        )
+                        avatar_btn = gr.Button("Generate Avatar")
+                        avatar_output = gr.Textbox(
+                            label="Avatar Status", lines=4, interactive=False
+                        )
+                        avatar_btn.click(
+                            use_ai_model, [avatar_model, avatar_input], avatar_output
+                        )
+
+            with gr.Tab("Arabic-English"):
+                gr.Markdown("### Arabic-English Interactive Models (12 models)")
+                arabic_model = gr.Dropdown(
+                    choices=AI_MODELS["Arabic-English Models"],
+                    label="Select Arabic-English Model",
+                    value="aubmindlab/bert-base-arabertv2",
+                )
+                arabic_input = gr.Textbox(
+                    label="Text (Arabic or English)",
+                    placeholder="أدخل النص باللغة العربية أو الإنجليزية / Enter text in Arabic or English...",
+                    lines=4,
+                )
+                arabic_btn = gr.Button("Process Arabic-English")
+                arabic_output = gr.Textbox(
+                    label="Processing Result", lines=6, interactive=False
+                )
+                arabic_btn.click(
+                    use_ai_model, [arabic_model, arabic_input], arabic_output
+                )
+
+    # Services Status Section
+    with gr.Row():
+        with gr.Column(elem_classes="section"):
+            gr.Markdown("## ☁️ Cloudflare Services Integration")
+
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Services Status")
+                    services_status = gr.Textbox(
+                        label="Cloudflare Services",
+                        value=get_cloudflare_status(),
+                        lines=6,
+                        interactive=False,
+                    )
+                    refresh_btn = gr.Button("Refresh Status")
+                    refresh_btn.click(
+                        lambda: get_cloudflare_status(), outputs=services_status
+                    )
+
+                with gr.Column():
+                    gr.Markdown("### Configuration")
+                    gr.HTML(
+                        """
+                    <div style="background: #f0f8ff; padding: 15px; border-radius: 10px;">
+                        <h4>Environment Variables:</h4>
+                        <ul>
+                            <li><code>CLOUDFLARE_API_TOKEN</code> - API authentication</li>
+                            <li><code>CLOUDFLARE_ACCOUNT_ID</code> - Account identifier</li>
+                            <li><code>CLOUDFLARE_D1_DATABASE_ID</code> - D1 database</li>
+                            <li><code>CLOUDFLARE_R2_BUCKET_NAME</code> - R2 storage</li>
+                            <li><code>CLOUDFLARE_KV_NAMESPACE_ID</code> - KV cache</li>
+                            <li><code>CLOUDFLARE_DURABLE_OBJECTS_ID</code> - Durable objects</li>
+                        </ul>
+                    </div>
+                    """
+                    )
+
+    # Footer Status
+    gr.HTML(
+        """
+    <div style="background: linear-gradient(45deg, #f0f8ff 0%, #e6f3ff 100%); padding: 20px; border-radius: 15px; margin-top: 25px; text-align: center;">
+        <h3>📊 Platform Status</h3>
+        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin: 15px 0;">
+            <div>✅ <strong>Authentication:</strong> Active</div>
+            <div>🧠 <strong>AI Models:</strong> 200+ Ready</div>
+            <div>🖼️ <strong>Image Processing:</strong> Available</div>
+            <div>🎵 <strong>Audio AI:</strong> Enabled</div>
+            <div>👤 <strong>Face/Avatar:</strong> Ready</div>
+            <div>🌍 <strong>Arabic-English:</strong> Supported</div>
+            <div>☁️ <strong>Cloudflare:</strong> Configurable</div>
+            <div>🚀 <strong>Platform:</strong> Production Ready</div>
+        </div>
+        <p><em>Complete AI Platform successfully deployed on HuggingFace Spaces with Docker!</em></p>
+    </div>
+    """
+    )
+
+if __name__ == "__main__":
+    app.launch(server_name="0.0.0.0", server_port=7860)

config/config.example.toml

@@ -0,0 +1,105 @@
+# Global LLM configuration
+[llm]
+model = "claude-3-7-sonnet-20250219"       # The LLM model to use
+base_url = "https://api.anthropic.com/v1/" # API endpoint URL
+api_key = "YOUR_API_KEY"                   # Your API key
+max_tokens = 8192                          # Maximum number of tokens in the response
+temperature = 0.0                          # Controls randomness
+
+# [llm] # Amazon Bedrock
+# api_type = "aws"                                       # Required
+# model = "us.anthropic.claude-3-7-sonnet-20250219-v1:0" # Bedrock supported modelID
+# base_url = "bedrock-runtime.us-west-2.amazonaws.com"   # Not used now
+# max_tokens = 8192
+# temperature = 1.0
+# api_key = "bear"                                       # Required but not used for Bedrock
+
+# [llm] #AZURE OPENAI:
+# api_type= 'azure'
+# model = "YOUR_MODEL_NAME" #"gpt-4o-mini"
+# base_url = "{YOUR_AZURE_ENDPOINT.rstrip('/')}/openai/deployments/{AZURE_DEPLOYMENT_ID}"
+# api_key = "AZURE API KEY"
+# max_tokens = 8096
+# temperature = 0.0
+# api_version="AZURE API VERSION" #"2024-08-01-preview"
+
+# [llm] #OLLAMA:
+# api_type = 'ollama'
+# model = "llama3.2"
+# base_url = "http://localhost:11434/v1"
+# api_key = "ollama"
+# max_tokens = 4096
+# temperature = 0.0
+
+# Optional configuration for specific LLM models
+[llm.vision]
+model = "claude-3-7-sonnet-20250219"       # The vision model to use
+base_url = "https://api.anthropic.com/v1/" # API endpoint URL for vision model
+api_key = "YOUR_API_KEY"                   # Your API key for vision model
+max_tokens = 8192                          # Maximum number of tokens in the response
+temperature = 0.0                          # Controls randomness for vision model
+
+# [llm.vision] #OLLAMA VISION:
+# api_type = 'ollama'
+# model = "llama3.2-vision"
+# base_url = "http://localhost:11434/v1"
+# api_key = "ollama"
+# max_tokens = 4096
+# temperature = 0.0
+
+# Optional configuration for specific browser configuration
+# [browser]
+# Whether to run browser in headless mode (default: false)
+#headless = false
+# Disable browser security features (default: true)
+#disable_security = true
+# Extra arguments to pass to the browser
+#extra_chromium_args = []
+# Path to a Chrome instance to use to connect to your normal browser
+# e.g. '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
+#chrome_instance_path = ""
+# Connect to a browser instance via WebSocket
+#wss_url = ""
+# Connect to a browser instance via CDP
+#cdp_url = ""
+
+# Optional configuration, Proxy settings for the browser
+# [browser.proxy]
+# server = "http://proxy-server:port"
+# username = "proxy-username"
+# password = "proxy-password"
+
+# Optional configuration, Search settings.
+# [search]
+# Search engine for agent to use. Default is "Google", can be set to "Baidu" or "DuckDuckGo" or "Bing".
+#engine = "Google"
+# Fallback engine order. Default is ["DuckDuckGo", "Baidu", "Bing"] - will try in this order after primary engine fails.
+#fallback_engines = ["DuckDuckGo", "Baidu", "Bing"]
+# Seconds to wait before retrying all engines again when they all fail due to rate limits. Default is 60.
+#retry_delay = 60
+# Maximum number of times to retry all engines when all fail. Default is 3.
+#max_retries = 3
+# Language code for search results. Options: "en" (English), "zh" (Chinese), etc.
+#lang = "en"
+# Country code for search results. Options: "us" (United States), "cn" (China), etc.
+#country = "us"
+
+
+## Sandbox configuration
+#[sandbox]
+#use_sandbox = false
+#image = "python:3.12-slim"
+#work_dir = "/workspace"
+#memory_limit = "1g"  # 512m
+#cpu_limit = 2.0
+#timeout = 300
+#network_enabled = true
+
+# MCP (Model Context Protocol) configuration
+[mcp]
+server_reference = "app.mcp.server" # default server module reference
+
+# Optional Runflow configuration
+# Your can add additional agents into run-flow workflow to solve different-type tasks.
+[runflow]
+use_data_analysis_agent = false     # The Data Analysi Agent to solve various data analysis tasks

docker-commands.md

@@ -0,0 +1,49 @@
+# OpenManus Docker Commands
+# Build and run the OpenManus platform locally
+
+# 1. Build the Docker image locally
+docker build -t openmanus-local .
+
+# 2. Run the container locally (recommended)
+docker run -it -p 7860:7860 --platform=linux/amd64 openmanus-local
+
+# 3. Run with environment variables (for Cloudflare integration)
+docker run -it -p 7860:7860 --platform=linux/amd64 \
+  -e CLOUDFLARE_API_TOKEN="your-token" \
+  -e CLOUDFLARE_ACCOUNT_ID="your-account-id" \
+  -e CLOUDFLARE_D1_DATABASE_ID="your-d1-id" \
+  -e CLOUDFLARE_R2_BUCKET_NAME="your-r2-bucket" \
+  -e CLOUDFLARE_KV_NAMESPACE_ID="your-kv-id" \
+  -e CLOUDFLARE_DURABLE_OBJECTS_ID="your-durable-objects-id" \
+  openmanus-local
+
+# 4. Run with volume mounts (for persistent data)
+docker run -it -p 7860:7860 --platform=linux/amd64 \
+  -v "${PWD}/data:/home/user/app/data" \
+  -v "${PWD}/logs:/home/user/app/logs" \
+  openmanus-local
+
+# 5. Run in background (daemon mode)
+docker run -d -p 7860:7860 --platform=linux/amd64 --name openmanus openmanus-local
+
+# 6. Run from HuggingFace registry - NEW HHH SPACE
+docker run -it -p 7860:7860 --platform=linux/amd64 \
+  registry.hf.space/speedofmastery-hhh:latest
+
+# 6b. Run from old agnt space (backup)
+docker run -it -p 7860:7860 --platform=linux/amd64 \
+  registry.hf.space/speedofmastery-agnt:latest
+
+# 7. Debug mode with shell access
+docker run -it --platform=linux/amd64 openmanus-local /bin/bash
+
+# 8. Check running containers
+docker ps
+
+# 9. Stop the container
+docker stop openmanus
+
+# 10. Remove the container
+docker rm openmanus
+
+# Access the platform at: http://localhost:7860

requirements.txt

@@ -0,0 +1 @@
+gradio>=4.0

requirements_backup.txt

@@ -0,0 +1,76 @@
+pydantic~=2.10.6
+openai~=1.66.3
+tenacity~=9.0.0
+pyyaml~=6.0.2
+loguru~=0.7.3
+numpy
+datasets~=3.4.1
+fastapi~=0.115.11
+tiktoken~=0.9.0
+
+html2text~=2024.2.26
+gymnasium~=1.1.1
+pillow~=11.1.0
+browsergym~=0.13.3
+uvicorn~=0.34.0
+unidiff~=0.7.5
+browser-use~=0.1.40
+googlesearch-python~=1.3.0
+baidusearch~=1.0.3
+duckduckgo_search~=7.5.3
+
+aiofiles~=24.1.0
+pydantic_core~=2.27.2
+colorama~=0.4.6
+playwright~=1.51.0
+
+docker~=7.1.0
+pytest~=8.3.5
+pytest-asyncio~=0.25.3
+
+mcp~=1.5.0
+httpx>=0.27.0
+tomli>=2.0.0
+
+boto3~=1.37.18
+
+requests~=2.32.3
+beautifulsoup4~=4.13.3
+crawl4ai~=0.6.3
+
+huggingface-hub~=0.29.2
+transformers~=4.46.0
+torch>=2.0.0
+gradio>=4.0,<5.0
+setuptools~=75.8.0
+
+# Authentication dependencies
+bcrypt~=4.0.1
+
+# Cloudflare integrations - Complete stack
+aiohttp~=3.9.0
+websockets~=12.0
+httpx~=0.25.0
+cloudflare~=2.20.1
+cffi~=1.16.0
+cryptography~=42.0.0
+
+# Additional backend dependencies
+asyncio-mqtt~=0.16.2
+aiodns~=3.2.0
+cchardet~=2.1.7
+charset-normalizer~=3.4.0
+python-dotenv~=1.0.0
+
+# Essential dependencies for production deployment
+pandas>=1.5.0
+numpy>=1.21.0
+Pillow>=8.0.0
+python-multipart>=0.0.5
+email-validator>=1.1.0
+passlib>=1.7.4
+python-jose>=3.3.0
+
+# Additional dependencies for Hugging Face Spaces and models integration
+gradio~=4.44.0
+spaces~=0.19.4

requirements_fixed.txt

@@ -0,0 +1,44 @@
+# Core dependencies
+pydantic>=2.0,<3.0
+fastapi>=0.100.0
+uvicorn>=0.20.0
+gradio>=4.0,<5.0
+
+# AI and ML
+huggingface-hub>=0.20.0
+transformers>=4.30.0
+torch>=2.0.0
+datasets>=2.0.0
+numpy>=1.21.0
+pillow>=8.0.0
+
+# Authentication and security
+bcrypt>=4.0.0
+python-multipart>=0.0.5
+python-jose>=3.3.0
+passlib>=1.7.4
+
+# Async and HTTP
+aiohttp>=3.8.0
+aiofiles>=22.0.0
+httpx>=0.24.0
+websockets>=10.0
+
+# Data processing
+pandas>=1.5.0
+pyyaml>=6.0.0
+requests>=2.28.0
+beautifulsoup4>=4.11.0
+
+# Logging and utilities
+loguru>=0.7.0
+python-dotenv>=1.0.0
+tenacity>=8.0.0
+colorama>=0.4.0
+
+# Cloudflare (optional)
+cloudflare>=2.0.0
+cryptography>=40.0.0
+
+# Additional utilities
+setuptools>=60.0.0

requirements_new.txt

@@ -0,0 +1,33 @@
+# Core framework - compatible versions
+fastapi>=0.100.0,<0.116.0
+uvicorn>=0.20.0,<0.35.0
+pydantic>=2.0,<3.0
+starlette>=0.35.0,<0.42.0
+
+# Gradio and UI - stable version
+gradio>=4.0,<5.0
+
+# HTTP and networking - core only
+httpx>=0.25.0,<0.29.0
+requests>=2.28.0,<2.33.0
+
+# Database - minimal setup
+bcrypt>=4.0.0,<5.0.0
+
+# AI essentials - lightweight
+openai>=1.0.0,<2.0.0
+huggingface-hub>=0.20.0,<1.0.0
+
+# Basic utilities
+python-dotenv>=1.0.0,<2.0.0
+pyyaml>=6.0,<7.0
+python-multipart>=0.0.6
+
+# System utilities
+pillow>=10.0.0
+numpy>=1.20.0
+
+# Additional basics
+typing-extensions>=4.0.0
+loguru>=0.7.0
+tenacity>=8.0.0

schema.sql

@@ -0,0 +1,135 @@
+-- OpenManus Database Schema for Cloudflare D1
+
+-- Users table to store user information
+CREATE TABLE IF NOT EXISTS users (
+    id TEXT PRIMARY KEY,
+    mobile_number TEXT UNIQUE NOT NULL,
+    full_name TEXT NOT NULL,
+    password_hash TEXT NOT NULL,
+    avatar_url TEXT,
+    preferences TEXT, -- JSON string for user preferences
+    is_active BOOLEAN DEFAULT TRUE,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Sessions table to store user sessions
+CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    title TEXT,
+    metadata TEXT, -- JSON string for session metadata
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    expires_at DATETIME,
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+);
+
+-- Conversations table to store chat messages
+CREATE TABLE IF NOT EXISTS conversations (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    role TEXT NOT NULL, -- 'user', 'assistant', 'system'
+    content TEXT NOT NULL,
+    metadata TEXT, -- JSON string for message metadata (files, tools used, etc.)
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+);
+
+-- Files table to store uploaded file information
+CREATE TABLE IF NOT EXISTS files (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    session_id TEXT,
+    filename TEXT NOT NULL,
+    content_type TEXT,
+    size INTEGER,
+    r2_key TEXT NOT NULL, -- Key in R2 storage
+    bucket TEXT NOT NULL, -- Which R2 bucket
+    metadata TEXT, -- JSON string for file metadata
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+    FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE SET NULL
+);
+
+-- Agents table to store agent configurations
+CREATE TABLE IF NOT EXISTS agents (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    name TEXT NOT NULL,
+    description TEXT,
+    system_prompt TEXT,
+    model TEXT,
+    tools TEXT, -- JSON array of enabled tools
+    config TEXT, -- JSON configuration object
+    is_active BOOLEAN DEFAULT TRUE,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+);
+
+-- Agent sessions table for durable object session tracking
+CREATE TABLE IF NOT EXISTS agent_sessions (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL,
+    user_id TEXT NOT NULL,
+    session_id TEXT NOT NULL,
+    durable_object_id TEXT, -- ID of the corresponding durable object
+    status TEXT DEFAULT 'active', -- 'active', 'paused', 'completed', 'error'
+    metadata TEXT, -- JSON string for session state
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (agent_id) REFERENCES agents(id) ON DELETE CASCADE,
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+    FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+);
+
+-- Usage tracking table for monitoring and analytics
+CREATE TABLE IF NOT EXISTS usage_logs (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    session_id TEXT,
+    agent_id TEXT,
+    action TEXT NOT NULL, -- 'chat', 'upload', 'tool_use', etc.
+    resource_type TEXT, -- 'd1', 'r2', 'kv', 'durable_object'
+    resource_id TEXT,
+    tokens_used INTEGER DEFAULT 0,
+    duration_ms INTEGER DEFAULT 0,
+    cost_cents INTEGER DEFAULT 0,
+    metadata TEXT, -- JSON string for additional details
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+    FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE SET NULL,
+    FOREIGN KEY (agent_id) REFERENCES agents(id) ON DELETE SET NULL
+);
+
+-- Create indexes for better performance
+CREATE INDEX IF NOT EXISTS idx_users_mobile_number ON users(mobile_number);
+CREATE INDEX IF NOT EXISTS idx_sessions_user_id ON sessions(user_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_created_at ON sessions(created_at);
+CREATE INDEX IF NOT EXISTS idx_conversations_session_id ON conversations(session_id);
+CREATE INDEX IF NOT EXISTS idx_conversations_created_at ON conversations(created_at);
+CREATE INDEX IF NOT EXISTS idx_files_user_id ON files(user_id);
+CREATE INDEX IF NOT EXISTS idx_files_session_id ON files(session_id);
+CREATE INDEX IF NOT EXISTS idx_files_created_at ON files(created_at);
+CREATE INDEX IF NOT EXISTS idx_agents_user_id ON agents(user_id);
+CREATE INDEX IF NOT EXISTS idx_agent_sessions_user_id ON agent_sessions(user_id);
+CREATE INDEX IF NOT EXISTS idx_agent_sessions_session_id ON agent_sessions(session_id);
+CREATE INDEX IF NOT EXISTS idx_usage_logs_user_id ON usage_logs(user_id);
+CREATE INDEX IF NOT EXISTS idx_usage_logs_created_at ON usage_logs(created_at);
+
+-- Insert a default system user for system-level operations
+INSERT OR IGNORE INTO users (id, mobile_number, full_name, password_hash)
+VALUES ('system', '0000000000', 'OpenManus System', 'system_hash');
+
+-- Insert a default agent configuration
+INSERT OR IGNORE INTO agents (id, user_id, name, description, system_prompt, model, tools)
+VALUES (
+    'default-agent',
+    'system',
+    'OpenManus Assistant',
+    'Default OpenManus AI assistant with full capabilities',
+    'You are OpenManus, an intelligent AI assistant with access to various tools and services. You help users with a wide range of tasks including file management, data analysis, web browsing, and more. Always be helpful, accurate, and concise in your responses.',
+    'gpt-4-turbo-preview',
+    '["file_operations", "web_search", "data_analysis", "browser_use", "python_execute"]'
+);

start.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+# OpenManus Platform - Linux Startup Script
+
+echo "🐧 Starting OpenManus Platform on Linux..."
+
+# Create necessary directories
+mkdir -p logs data cache
+
+# Set proper permissions
+chmod +x app.py
+
+# Check Python and show system info
+echo "� System Information:"
+echo "Python version: $(python3 --version)"
+echo "Working directory: $(pwd)"
+echo "User: $(whoami)"
+
+# List files to verify everything is in place
+echo "� Files in directory:"
+ls -la
+
+# Start the application
+echo "🚀 Launching OpenManus Platform..."
+exec python3 app.py