update README and format code

feat: refactor the LLM (using LiteLLM & add cost calculation)

README.md

@@ -9,8 +9,7 @@ English | [中文](README_zh.md)
 
 Manus is incredible, but OpenManus can achieve any idea without an *Invite Code* 🛫!
 
-Our team
-members [@mannaandpoem](https://github.com/mannaandpoem) [@XiangJinyu](https://github.com/XiangJinyu) [@MoshiQAQ](https://github.com/MoshiQAQ) [@didiforgithub](https://github.com/didiforgithub) [@stellaHSR](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!
+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!
 
@@ -144,6 +143,8 @@ Join our networking group on Feishu and share your experience with other develop
 Thanks to [anthropic-computer-use](https://github.com/anthropics/anthropic-quickstarts/tree/main/computer-use-demo)
 and [browser-use](https://github.com/browser-use/browser-use) 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) and [OpenHands](https://github.com/All-Hands-AI/OpenHands).
+
 OpenManus is built by contributors from MetaGPT. Huge thanks to this agent community!
 
 ## Cite

README_zh.md

@@ -145,4 +145,6 @@ python run_flow.py
 特别感谢 [anthropic-computer-use](https://github.com/anthropics/anthropic-quickstarts/tree/main/computer-use-demo)
 和 [browser-use](https://github.com/browser-use/browser-use) 为本项目提供的基础支持！
 
+此外，我们感谢 [AAAJ](https://github.com/metauto-ai/agent-as-a-judge)，[MetaGPT](https://github.com/geekan/MetaGPT) 和 [OpenHands](https://github.com/All-Hands-AI/OpenHands).
+
 OpenManus 由 MetaGPT 社区的贡献者共同构建，感谢这个充满活力的智能体开发者社区！

app.py

@@ -1,255 +0,0 @@
-import asyncio
-import threading
-import uuid
-import webbrowser
-from datetime import datetime
-from json import dumps
-
-from fastapi import Body, FastAPI, HTTPException, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse
-from fastapi.staticfiles import StaticFiles
-from fastapi.templating import Jinja2Templates
-from pydantic import BaseModel
-
-
-app = FastAPI()
-
-app.mount("/static", StaticFiles(directory="static"), name="static")
-templates = Jinja2Templates(directory="templates")
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-class Task(BaseModel):
-    id: str
-    prompt: str
-    created_at: datetime
-    status: str
-    steps: list = []
-
-    def model_dump(self, *args, **kwargs):
-        data = super().model_dump(*args, **kwargs)
-        data["created_at"] = self.created_at.isoformat()
-        return data
-
-
-class TaskManager:
-    def __init__(self):
-        self.tasks = {}
-        self.queues = {}
-
-    def create_task(self, prompt: str) -> Task:
-        task_id = str(uuid.uuid4())
-        task = Task(
-            id=task_id, prompt=prompt, created_at=datetime.now(), status="pending"
-        )
-        self.tasks[task_id] = task
-        self.queues[task_id] = asyncio.Queue()
-        return task
-
-    async def update_task_step(
-        self, task_id: str, step: int, result: str, step_type: str = "step"
-    ):
-        if task_id in self.tasks:
-            task = self.tasks[task_id]
-            task.steps.append({"step": step, "result": result, "type": step_type})
-            await self.queues[task_id].put(
-                {"type": step_type, "step": step, "result": result}
-            )
-            await self.queues[task_id].put(
-                {"type": "status", "status": task.status, "steps": task.steps}
-            )
-
-    async def complete_task(self, task_id: str):
-        if task_id in self.tasks:
-            task = self.tasks[task_id]
-            task.status = "completed"
-            await self.queues[task_id].put(
-                {"type": "status", "status": task.status, "steps": task.steps}
-            )
-            await self.queues[task_id].put({"type": "complete"})
-
-    async def fail_task(self, task_id: str, error: str):
-        if task_id in self.tasks:
-            self.tasks[task_id].status = f"failed: {error}"
-            await self.queues[task_id].put({"type": "error", "message": error})
-
-
-task_manager = TaskManager()
-
-
-@app.get("/", response_class=HTMLResponse)
-async def index(request: Request):
-    return templates.TemplateResponse("index.html", {"request": request})
-
-
-@app.post("/tasks")
-async def create_task(prompt: str = Body(..., embed=True)):
-    task = task_manager.create_task(prompt)
-    asyncio.create_task(run_task(task.id, prompt))
-    return {"task_id": task.id}
-
-
-from app.agent.manus import Manus
-
-
-async def run_task(task_id: str, prompt: str):
-    try:
-        task_manager.tasks[task_id].status = "running"
-
-        agent = Manus(
-            name="Manus",
-            description="A versatile agent that can solve various tasks using multiple tools",
-            max_steps=30,
-        )
-
-        async def on_think(thought):
-            await task_manager.update_task_step(task_id, 0, thought, "think")
-
-        async def on_tool_execute(tool, input):
-            await task_manager.update_task_step(
-                task_id, 0, f"Executing tool: {tool}\nInput: {input}", "tool"
-            )
-
-        async def on_action(action):
-            await task_manager.update_task_step(
-                task_id, 0, f"Executing action: {action}", "act"
-            )
-
-        async def on_run(step, result):
-            await task_manager.update_task_step(task_id, step, result, "run")
-
-        from app.logger import logger
-
-        class SSELogHandler:
-            def __init__(self, task_id):
-                self.task_id = task_id
-
-            async def __call__(self, message):
-                import re
-
-                # 提取 - 后面的内容
-                cleaned_message = re.sub(r"^.*? - ", "", message)
-
-                event_type = "log"
-                if "✨ Manus's thoughts:" in cleaned_message:
-                    event_type = "think"
-                elif "🛠️ Manus selected" in cleaned_message:
-                    event_type = "tool"
-                elif "🎯 Tool" in cleaned_message:
-                    event_type = "act"
-                elif "📝 Oops!" in cleaned_message:
-                    event_type = "error"
-                elif "🏁 Special tool" in cleaned_message:
-                    event_type = "complete"
-
-                await task_manager.update_task_step(
-                    self.task_id, 0, cleaned_message, event_type
-                )
-
-        sse_handler = SSELogHandler(task_id)
-        logger.add(sse_handler)
-
-        result = await agent.run(prompt)
-        await task_manager.update_task_step(task_id, 1, result, "result")
-        await task_manager.complete_task(task_id)
-    except Exception as e:
-        await task_manager.fail_task(task_id, str(e))
-
-
-@app.get("/tasks/{task_id}/events")
-async def task_events(task_id: str):
-    async def event_generator():
-        if task_id not in task_manager.queues:
-            yield f"event: error\ndata: {dumps({'message': 'Task not found'})}\n\n"
-            return
-
-        queue = task_manager.queues[task_id]
-
-        task = task_manager.tasks.get(task_id)
-        if task:
-            yield f"event: status\ndata: {dumps({'type': 'status', 'status': task.status, 'steps': task.steps})}\n\n"
-
-        while True:
-            try:
-                event = await queue.get()
-                formatted_event = dumps(event)
-
-                yield ": heartbeat\n\n"
-
-                if event["type"] == "complete":
-                    yield f"event: complete\ndata: {formatted_event}\n\n"
-                    break
-                elif event["type"] == "error":
-                    yield f"event: error\ndata: {formatted_event}\n\n"
-                    break
-                elif event["type"] == "step":
-                    task = task_manager.tasks.get(task_id)
-                    if task:
-                        yield f"event: status\ndata: {dumps({'type': 'status', 'status': task.status, 'steps': task.steps})}\n\n"
-                    yield f"event: {event['type']}\ndata: {formatted_event}\n\n"
-                elif event["type"] in ["think", "tool", "act", "run"]:
-                    yield f"event: {event['type']}\ndata: {formatted_event}\n\n"
-                else:
-                    yield f"event: {event['type']}\ndata: {formatted_event}\n\n"
-
-            except asyncio.CancelledError:
-                print(f"Client disconnected for task {task_id}")
-                break
-            except Exception as e:
-                print(f"Error in event stream: {str(e)}")
-                yield f"event: error\ndata: {dumps({'message': str(e)})}\n\n"
-                break
-
-    return StreamingResponse(
-        event_generator(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",
-        },
-    )
-
-
-@app.get("/tasks")
-async def get_tasks():
-    sorted_tasks = sorted(
-        task_manager.tasks.values(), key=lambda task: task.created_at, reverse=True
-    )
-    return JSONResponse(
-        content=[task.model_dump() for task in sorted_tasks],
-        headers={"Content-Type": "application/json"},
-    )
-
-
-@app.get("/tasks/{task_id}")
-async def get_task(task_id: str):
-    if task_id not in task_manager.tasks:
-        raise HTTPException(status_code=404, detail="Task not found")
-    return task_manager.tasks[task_id]
-
-
-@app.exception_handler(Exception)
-async def generic_exception_handler(request: Request, exc: Exception):
-    return JSONResponse(
-        status_code=500, content={"message": f"Server error: {str(exc)}"}
-    )
-
-
-def open_local_browser():
-    webbrowser.open_new_tab("http://localhost:5172")
-
-
-if __name__ == "__main__":
-    import uvicorn
-
-    threading.Timer(3, open_local_browser).start()
-    uvicorn.run(app, host="localhost", port=5172)

app/agent/base.py

@@ -4,7 +4,7 @@ from typing import List, Literal, Optional
 
 from pydantic import BaseModel, Field, model_validator
 
-from app.llm import LLM
+from app.llm.inference import LLM
 from app.logger import logger
 from app.schema import AgentState, Memory, Message
 
@@ -144,6 +144,8 @@ class BaseAgent(BaseModel, ABC):
                 results.append(f"Step {self.current_step}: {step_result}")
 
             if self.current_step >= self.max_steps:
+                self.current_step = 0  # setting back to 0 when reached max steps
+                self.state = AgentState.IDLE  # setting the status
                 results.append(f"Terminated: Reached max steps ({self.max_steps})")
 
         return "\n".join(results) if results else "No steps executed"

app/agent/manus.py

@@ -32,3 +32,5 @@ class Manus(ToolCallAgent):
             PythonExecute(), GoogleSearch(), BrowserUseTool(), FileSaver(), Terminate()
         )
     )
+
+    max_steps: int = 20

app/agent/react.py

@@ -4,7 +4,7 @@ from typing import Optional
 from pydantic import Field
 
 from app.agent.base import BaseAgent
-from app.llm import LLM
+from app.llm.inference import LLM
 from app.schema import AgentState, Memory
 
 

app/flow/planning.py

@@ -6,7 +6,7 @@ from pydantic import Field
 
 from app.agent.base import BaseAgent
 from app.flow.base import BaseFlow, PlanStepStatus
-from app.llm import LLM
+from app.llm.inference import LLM
 from app.logger import logger
 from app.schema import AgentState, Message
 from app.tool import PlanningTool

app/llm.py

@@ -1,264 +0,0 @@
-from typing import Dict, List, Literal, Optional, Union
-
-from openai import (
-    APIError,
-    AsyncAzureOpenAI,
-    AsyncOpenAI,
-    AuthenticationError,
-    OpenAIError,
-    RateLimitError,
-)
-from tenacity import retry, stop_after_attempt, wait_random_exponential
-
-from app.config import LLMSettings, config
-from app.logger import logger  # Assuming a logger is set up in your app
-from app.schema import Message
-
-
-class LLM:
-    _instances: Dict[str, "LLM"] = {}
-
-    def __new__(
-        cls, config_name: str = "default", llm_config: Optional[LLMSettings] = None
-    ):
-        if config_name not in cls._instances:
-            instance = super().__new__(cls)
-            instance.__init__(config_name, llm_config)
-            cls._instances[config_name] = instance
-        return cls._instances[config_name]
-
-    def __init__(
-        self, config_name: str = "default", llm_config: Optional[LLMSettings] = None
-    ):
-        if not hasattr(self, "client"):  # Only initialize if not already initialized
-            llm_config = llm_config or config.llm
-            llm_config = llm_config.get(config_name, llm_config["default"])
-            self.model = llm_config.model
-            self.max_tokens = llm_config.max_tokens
-            self.temperature = llm_config.temperature
-            self.api_type = llm_config.api_type
-            self.api_key = llm_config.api_key
-            self.api_version = llm_config.api_version
-            self.base_url = llm_config.base_url
-            if self.api_type == "azure":
-                self.client = AsyncAzureOpenAI(
-                    base_url=self.base_url,
-                    api_key=self.api_key,
-                    api_version=self.api_version,
-                )
-            else:
-                self.client = AsyncOpenAI(api_key=self.api_key, base_url=self.base_url)
-
-    @staticmethod
-    def format_messages(messages: List[Union[dict, Message]]) -> List[dict]:
-        """
-        Format messages for LLM by converting them to OpenAI message format.
-
-        Args:
-            messages: List of messages that can be either dict or Message objects
-
-        Returns:
-            List[dict]: List of formatted messages in OpenAI format
-
-        Raises:
-            ValueError: If messages are invalid or missing required fields
-            TypeError: If unsupported message types are provided
-
-        Examples:
-            >>> msgs = [
-            ...     Message.system_message("You are a helpful assistant"),
-            ...     {"role": "user", "content": "Hello"},
-            ...     Message.user_message("How are you?")
-            ... ]
-            >>> formatted = LLM.format_messages(msgs)
-        """
-        formatted_messages = []
-
-        for message in messages:
-            if isinstance(message, dict):
-                # If message is already a dict, ensure it has required fields
-                if "role" not in message:
-                    raise ValueError("Message dict must contain 'role' field")
-                formatted_messages.append(message)
-            elif isinstance(message, Message):
-                # If message is a Message object, convert it to dict
-                formatted_messages.append(message.to_dict())
-            else:
-                raise TypeError(f"Unsupported message type: {type(message)}")
-
-        # Validate all messages have required fields
-        for msg in formatted_messages:
-            if msg["role"] not in ["system", "user", "assistant", "tool"]:
-                raise ValueError(f"Invalid role: {msg['role']}")
-            if "content" not in msg and "tool_calls" not in msg:
-                raise ValueError(
-                    "Message must contain either 'content' or 'tool_calls'"
-                )
-
-        return formatted_messages
-
-    @retry(
-        wait=wait_random_exponential(min=1, max=60),
-        stop=stop_after_attempt(6),
-    )
-    async def ask(
-        self,
-        messages: List[Union[dict, Message]],
-        system_msgs: Optional[List[Union[dict, Message]]] = None,
-        stream: bool = True,
-        temperature: Optional[float] = None,
-    ) -> str:
-        """
-        Send a prompt to the LLM and get the response.
-
-        Args:
-            messages: List of conversation messages
-            system_msgs: Optional system messages to prepend
-            stream (bool): Whether to stream the response
-            temperature (float): Sampling temperature for the response
-
-        Returns:
-            str: The generated response
-
-        Raises:
-            ValueError: If messages are invalid or response is empty
-            OpenAIError: If API call fails after retries
-            Exception: For unexpected errors
-        """
-        try:
-            # Format system and user messages
-            if system_msgs:
-                system_msgs = self.format_messages(system_msgs)
-                messages = system_msgs + self.format_messages(messages)
-            else:
-                messages = self.format_messages(messages)
-
-            if not stream:
-                # Non-streaming request
-                response = await self.client.chat.completions.create(
-                    model=self.model,
-                    messages=messages,
-                    max_tokens=self.max_tokens,
-                    temperature=temperature or self.temperature,
-                    stream=False,
-                )
-                if not response.choices or not response.choices[0].message.content:
-                    raise ValueError("Empty or invalid response from LLM")
-                return response.choices[0].message.content
-
-            # Streaming request
-            response = await self.client.chat.completions.create(
-                model=self.model,
-                messages=messages,
-                max_tokens=self.max_tokens,
-                temperature=temperature or self.temperature,
-                stream=True,
-            )
-
-            collected_messages = []
-            async for chunk in response:
-                chunk_message = chunk.choices[0].delta.content or ""
-                collected_messages.append(chunk_message)
-                print(chunk_message, end="", flush=True)
-
-            print()  # Newline after streaming
-            full_response = "".join(collected_messages).strip()
-            if not full_response:
-                raise ValueError("Empty response from streaming LLM")
-            return full_response
-
-        except ValueError as ve:
-            logger.error(f"Validation error: {ve}")
-            raise
-        except OpenAIError as oe:
-            logger.error(f"OpenAI API error: {oe}")
-            raise
-        except Exception as e:
-            logger.error(f"Unexpected error in ask: {e}")
-            raise
-
-    @retry(
-        wait=wait_random_exponential(min=1, max=60),
-        stop=stop_after_attempt(6),
-    )
-    async def ask_tool(
-        self,
-        messages: List[Union[dict, Message]],
-        system_msgs: Optional[List[Union[dict, Message]]] = None,
-        timeout: int = 60,
-        tools: Optional[List[dict]] = None,
-        tool_choice: Literal["none", "auto", "required"] = "auto",
-        temperature: Optional[float] = None,
-        **kwargs,
-    ):
-        """
-        Ask LLM using functions/tools and return the response.
-
-        Args:
-            messages: List of conversation messages
-            system_msgs: Optional system messages to prepend
-            timeout: Request timeout in seconds
-            tools: List of tools to use
-            tool_choice: Tool choice strategy
-            temperature: Sampling temperature for the response
-            **kwargs: Additional completion arguments
-
-        Returns:
-            ChatCompletionMessage: The model's response
-
-        Raises:
-            ValueError: If tools, tool_choice, or messages are invalid
-            OpenAIError: If API call fails after retries
-            Exception: For unexpected errors
-        """
-        try:
-            # Validate tool_choice
-            if tool_choice not in ["none", "auto", "required"]:
-                raise ValueError(f"Invalid tool_choice: {tool_choice}")
-
-            # Format messages
-            if system_msgs:
-                system_msgs = self.format_messages(system_msgs)
-                messages = system_msgs + self.format_messages(messages)
-            else:
-                messages = self.format_messages(messages)
-
-            # Validate tools if provided
-            if tools:
-                for tool in tools:
-                    if not isinstance(tool, dict) or "type" not in tool:
-                        raise ValueError("Each tool must be a dict with 'type' field")
-
-            # Set up the completion request
-            response = await self.client.chat.completions.create(
-                model=self.model,
-                messages=messages,
-                temperature=temperature or self.temperature,
-                max_tokens=self.max_tokens,
-                tools=tools,
-                tool_choice=tool_choice,
-                timeout=timeout,
-                **kwargs,
-            )
-
-            # Check if response is valid
-            if not response.choices or not response.choices[0].message:
-                print(response)
-                raise ValueError("Invalid or empty response from LLM")
-
-            return response.choices[0].message
-
-        except ValueError as ve:
-            logger.error(f"Validation error in ask_tool: {ve}")
-            raise
-        except OpenAIError as oe:
-            if isinstance(oe, AuthenticationError):
-                logger.error("Authentication failed. Check API key.")
-            elif isinstance(oe, RateLimitError):
-                logger.error("Rate limit exceeded. Consider increasing retry attempts.")
-            elif isinstance(oe, APIError):
-                logger.error(f"API error: {oe}")
-            raise
-        except Exception as e:
-            logger.error(f"Unexpected error in ask_tool: {e}")
-            raise

app/llm/cost.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Cost:
+    """
+    Cost class can record various costs during running and evaluation.
+    Currently we define the following costs:
+        accumulated_cost: the total cost (USD $) of the current LLM.
+    """
+
+    def __init__(self) -> None:
+        self._accumulated_cost: float = 0.0
+        self._costs: list[float] = []
+
+    @property
+    def accumulated_cost(self) -> float:
+        return self._accumulated_cost
+
+    @accumulated_cost.setter
+    def accumulated_cost(self, value: float) -> None:
+        if value < 0:
+            raise ValueError("Total cost cannot be negative.")
+        self._accumulated_cost = value
+
+    @property
+    def costs(self) -> list:
+        return self._costs
+
+    def add_cost(self, value: float) -> None:
+        if value < 0:
+            raise ValueError("Added cost cannot be negative.")
+        self._accumulated_cost += value
+        self._costs.append(value)
+
+    def get(self):
+        """
+        Return the costs in a dictionary.
+        """
+        return {"accumulated_cost": self._accumulated_cost, "costs": self._costs}
+
+    def log(self):
+        """
+        Log the costs.
+        """
+        cost = self.get()
+        logs = ""
+        for key, value in cost.items():
+            logs += f"{key}: {value}\n"
+        return logs

app/llm/inference.py

@@ -0,0 +1,525 @@
+import base64
+import os
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+
+import litellm
+from litellm import completion, completion_cost
+from litellm.exceptions import (
+    APIConnectionError,
+    RateLimitError,
+    ServiceUnavailableError,
+)
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_random_exponential,
+)
+
+from app.config import LLMSettings, config
+from app.llm.cost import Cost
+from app.logger import logger
+from app.schema import Message
+
+
+class LLM:
+    _instances: Dict[str, "LLM"] = {}
+
+    def __new__(
+        cls, config_name: str = "default", llm_config: Optional[LLMSettings] = None
+    ):
+        if config_name not in cls._instances:
+            instance = super().__new__(cls)
+            instance.__init__(config_name, llm_config)
+            cls._instances[config_name] = instance
+        return cls._instances[config_name]
+
+    def __init__(
+        self, config_name: str = "default", llm_config: Optional[LLMSettings] = None
+    ):
+        if not hasattr(
+            self, "initialized"
+        ):  # Only initialize if not already initialized
+            llm_config = llm_config or config.llm
+            llm_config = llm_config.get(config_name, llm_config["default"])
+
+            self.model = getattr(llm_config, "model", "gpt-3.5-turbo")
+            self.max_tokens = getattr(llm_config, "max_tokens", 4096)
+            self.temperature = getattr(llm_config, "temperature", 0.7)
+            self.top_p = getattr(llm_config, "top_p", 0.9)
+            self.api_type = getattr(llm_config, "api_type", "openai")
+            self.api_key = getattr(
+                llm_config, "api_key", os.environ.get("OPENAI_API_KEY", "")
+            )
+            self.api_version = getattr(llm_config, "api_version", "")
+            self.base_url = getattr(llm_config, "base_url", "https://api.openai.com/v1")
+            self.timeout = getattr(llm_config, "timeout", 60)
+            self.num_retries = getattr(llm_config, "num_retries", 3)
+            self.retry_min_wait = getattr(llm_config, "retry_min_wait", 1)
+            self.retry_max_wait = getattr(llm_config, "retry_max_wait", 10)
+            self.custom_llm_provider = getattr(llm_config, "custom_llm_provider", None)
+
+            # Get model info if available
+            self.model_info = None
+            try:
+                self.model_info = litellm.get_model_info(self.model)
+            except Exception as e:
+                logger.warning(f"Could not get model info for {self.model}: {e}")
+
+            # Configure litellm
+            if self.api_type == "azure":
+                litellm.api_base = self.base_url
+                litellm.api_key = self.api_key
+                litellm.api_version = self.api_version
+            else:
+                litellm.api_key = self.api_key
+                if self.base_url:
+                    litellm.api_base = self.base_url
+
+            # Initialize cost tracker
+            self.cost_tracker = Cost()
+            self.initialized = True
+
+            # Initialize completion function
+            self._initialize_completion_function()
+
+    def _initialize_completion_function(self):
+        """Initialize the completion function with retry logic"""
+
+        def attempt_on_error(retry_state):
+            logger.error(
+                f"{retry_state.outcome.exception()}. Attempt #{retry_state.attempt_number}"
+            )
+            return True
+
+        @retry(
+            reraise=True,
+            stop=stop_after_attempt(self.num_retries),
+            wait=wait_random_exponential(
+                min=self.retry_min_wait, max=self.retry_max_wait
+            ),
+            retry=retry_if_exception_type(
+                (RateLimitError, APIConnectionError, ServiceUnavailableError)
+            ),
+            after=attempt_on_error,
+        )
+        def wrapper(*args, **kwargs):
+            model_name = self.model
+            if self.api_type == "azure":
+                model_name = f"azure/{self.model}"
+
+            # Set default parameters if not provided
+            if "max_tokens" not in kwargs:
+                kwargs["max_tokens"] = self.max_tokens
+            if "temperature" not in kwargs:
+                kwargs["temperature"] = self.temperature
+            if "top_p" not in kwargs:
+                kwargs["top_p"] = self.top_p
+            if "timeout" not in kwargs:
+                kwargs["timeout"] = self.timeout
+
+            kwargs["model"] = model_name
+
+            # Add API credentials if not in kwargs
+            if "api_key" not in kwargs:
+                kwargs["api_key"] = self.api_key
+            if "base_url" not in kwargs and self.base_url:
+                kwargs["base_url"] = self.base_url
+            if "api_version" not in kwargs and self.api_version:
+                kwargs["api_version"] = self.api_version
+            if "custom_llm_provider" not in kwargs and self.custom_llm_provider:
+                kwargs["custom_llm_provider"] = self.custom_llm_provider
+
+            resp = completion(**kwargs)
+            return resp
+
+        self._completion = wrapper
+
+    @staticmethod
+    def format_messages(messages: List[Union[dict, Message]]) -> List[dict]:
+        """
+        Format messages for LLM by converting them to OpenAI message format.
+
+        Args:
+            messages: List of messages that can be either dict or Message objects
+
+        Returns:
+            List[dict]: List of formatted messages in OpenAI format
+
+        Raises:
+            ValueError: If messages are invalid or missing required fields
+            TypeError: If unsupported message types are provided
+        """
+        formatted_messages = []
+
+        for message in messages:
+            if isinstance(message, dict):
+                # If message is already a dict, ensure it has required fields
+                if "role" not in message:
+                    raise ValueError("Message dict must contain 'role' field")
+                formatted_messages.append(message)
+            elif isinstance(message, Message):
+                # If message is a Message object, convert it to dict
+                formatted_messages.append(message.to_dict())
+            else:
+                raise TypeError(f"Unsupported message type: {type(message)}")
+
+        # Validate all messages have required fields
+        for msg in formatted_messages:
+            if msg["role"] not in ["system", "user", "assistant", "tool"]:
+                raise ValueError(f"Invalid role: {msg['role']}")
+            if "content" not in msg and "tool_calls" not in msg:
+                raise ValueError(
+                    "Message must contain either 'content' or 'tool_calls'"
+                )
+
+        return formatted_messages
+
+    def _calculate_and_track_cost(self, response) -> float:
+        """
+        Calculate and track the cost of an LLM API call.
+
+        Args:
+            response: The response from litellm
+
+        Returns:
+            float: The calculated cost
+        """
+        try:
+            # Use litellm's completion_cost function
+            cost = completion_cost(completion_response=response)
+
+            # Add the cost to our tracker
+            if cost > 0:
+                self.cost_tracker.add_cost(cost)
+                logger.info(
+                    f"Added cost: ${cost:.6f}, Total: ${self.cost_tracker.accumulated_cost:.6f}"
+                )
+
+            return cost
+        except Exception as e:
+            logger.warning(f"Cost calculation failed: {e}")
+            return 0.0
+
+    def is_local(self) -> bool:
+        """
+        Check if the model is running locally.
+
+        Returns:
+            bool: True if the model is running locally, False otherwise
+        """
+        if self.base_url:
+            return any(
+                substring in self.base_url
+                for substring in ["localhost", "127.0.0.1", "0.0.0.0"]
+            )
+        if self.model and (
+            self.model.startswith("ollama") or "local" in self.model.lower()
+        ):
+            return True
+        return False
+
+    def do_completion(self, *args, **kwargs) -> Tuple[Any, float, float]:
+        """
+        Perform a completion request and track cost.
+
+        Returns:
+            Tuple[Any, float, float]: (response, current_cost, accumulated_cost)
+        """
+        response = self._completion(*args, **kwargs)
+
+        # Calculate and track cost
+        current_cost = self._calculate_and_track_cost(response)
+
+        return response, current_cost, self.cost_tracker.accumulated_cost
+
+    @staticmethod
+    def encode_image(image_path: str) -> str:
+        """
+        Encode an image to base64.
+
+        Args:
+            image_path: Path to the image file
+
+        Returns:
+            str: Base64-encoded image
+        """
+        with open(image_path, "rb") as image_file:
+            return base64.b64encode(image_file.read()).decode("utf-8")
+
+    def prepare_messages(
+        self, text: str, image_path: Optional[str] = None
+    ) -> List[dict]:
+        """
+        Prepare messages for completion, including multimodal content if needed.
+
+        Args:
+            text: Text content
+            image_path: Optional path to an image file
+
+        Returns:
+            List[dict]: Formatted messages
+        """
+        messages = [{"role": "user", "content": text}]
+        if image_path:
+            base64_image = self.encode_image(image_path)
+            messages[0]["content"] = [
+                {"type": "text", "text": text},
+                {
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"},
+                },
+            ]
+        return messages
+
+    def do_multimodal_completion(
+        self, text: str, image_path: str
+    ) -> Tuple[Any, float, float]:
+        """
+        Perform a multimodal completion with text and image.
+
+        Args:
+            text: Text prompt
+            image_path: Path to the image file
+
+        Returns:
+            Tuple[Any, float, float]: (response, current_cost, accumulated_cost)
+        """
+        messages = self.prepare_messages(text, image_path=image_path)
+        return self.do_completion(messages=messages)
+
+    @retry(
+        wait=wait_random_exponential(min=1, max=60),
+        stop=stop_after_attempt(6),
+    )
+    async def ask(
+        self,
+        messages: List[Union[dict, Message]],
+        system_msgs: Optional[List[Union[dict, Message]]] = None,
+        stream: bool = True,
+        temperature: Optional[float] = None,
+    ) -> str:
+        """
+        Send a prompt to the LLM and get the response.
+
+        Args:
+            messages: List of conversation messages
+            system_msgs: Optional system messages to prepend
+            stream (bool): Whether to stream the response
+            temperature (float): Sampling temperature for the response
+
+        Returns:
+            str: The generated response
+
+        Raises:
+            ValueError: If messages are invalid or response is empty
+            Exception: For unexpected errors
+        """
+        try:
+            # Format system and user messages
+            if system_msgs:
+                system_msgs = self.format_messages(system_msgs)
+                messages = system_msgs + self.format_messages(messages)
+            else:
+                messages = self.format_messages(messages)
+
+            model_name = self.model
+            if self.api_type == "azure":
+                # For Azure, litellm expects model name in format: azure/<deployment_name>
+                model_name = f"azure/{self.model}"
+
+            if not stream:
+                # Non-streaming request
+                response = await litellm.acompletion(
+                    model=model_name,
+                    messages=messages,
+                    max_tokens=self.max_tokens,
+                    temperature=temperature or self.temperature,
+                    stream=False,
+                )
+
+                # Calculate and track cost
+                self._calculate_and_track_cost(response)
+
+                if not response.choices or not response.choices[0].message.content:
+                    raise ValueError("Empty or invalid response from LLM")
+                return response.choices[0].message.content
+
+            # Streaming request
+            collected_messages = []
+            async for chunk in await litellm.acompletion(
+                model=model_name,
+                messages=messages,
+                max_tokens=self.max_tokens,
+                temperature=temperature or self.temperature,
+                stream=True,
+            ):
+                chunk_message = chunk.choices[0].delta.content or ""
+                collected_messages.append(chunk_message)
+                print(chunk_message, end="", flush=True)
+
+            # For streaming responses, cost is calculated on the last chunk
+            if hasattr(chunk, "usage") and chunk.usage:
+                self._calculate_and_track_cost(chunk)
+
+            print()  # Newline after streaming
+            full_response = "".join(collected_messages).strip()
+            if not full_response:
+                raise ValueError("Empty response from streaming LLM")
+            return full_response
+
+        except ValueError as ve:
+            logger.error(f"Validation error: {ve}")
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error in ask: {e}")
+            raise
+
+    @retry(
+        wait=wait_random_exponential(min=1, max=60),
+        stop=stop_after_attempt(6),
+    )
+    async def ask_tool(
+        self,
+        messages: List[Union[dict, Message]],
+        system_msgs: Optional[List[Union[dict, Message]]] = None,
+        timeout: int = 60,
+        tools: Optional[List[dict]] = None,
+        tool_choice: Literal["none", "auto", "required"] = "auto",
+        temperature: Optional[float] = None,
+        **kwargs,
+    ):
+        """
+        Ask LLM using functions/tools and return the response.
+
+        Args:
+            messages: List of conversation messages
+            system_msgs: Optional system messages to prepend
+            timeout: Request timeout in seconds
+            tools: List of tools to use
+            tool_choice: Tool choice strategy
+            temperature: Sampling temperature for the response
+            **kwargs: Additional completion arguments
+
+        Returns:
+            The model's response
+
+        Raises:
+            ValueError: If tools, tool_choice, or messages are invalid
+            Exception: For unexpected errors
+        """
+        try:
+            # Validate tool_choice
+            if tool_choice not in ["none", "auto", "required"]:
+                raise ValueError(f"Invalid tool_choice: {tool_choice}")
+
+            # Format messages
+            if system_msgs:
+                system_msgs = self.format_messages(system_msgs)
+                messages = system_msgs + self.format_messages(messages)
+            else:
+                messages = self.format_messages(messages)
+
+            # Validate tools if provided
+            if tools:
+                for tool in tools:
+                    if not isinstance(tool, dict) or "type" not in tool:
+                        raise ValueError("Each tool must be a dict with 'type' field")
+
+            model_name = self.model
+            if self.api_type == "azure":
+                # For Azure, litellm expects model name in format: azure/<deployment_name>
+                model_name = f"azure/{self.model}"
+
+            # Set up the completion request
+            response = await litellm.acompletion(
+                model=model_name,
+                messages=messages,
+                temperature=temperature or self.temperature,
+                max_tokens=self.max_tokens,
+                tools=tools,
+                tool_choice=tool_choice,
+                timeout=timeout,
+                **kwargs,
+            )
+
+            # Calculate and track cost
+            self._calculate_and_track_cost(response)
+
+            # Check if response is valid
+            if not response.choices or not response.choices[0].message:
+                print(response)
+                raise ValueError("Invalid or empty response from LLM")
+
+            return response.choices[0].message
+
+        except ValueError as ve:
+            logger.error(f"Validation error: {ve}")
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error in ask_tool: {e}")
+            raise
+
+    def get_cost(self):
+        """
+        Get the current cost information.
+
+        Returns:
+            dict: Dictionary containing accumulated cost and individual costs
+        """
+        return self.cost_tracker.get()
+
+    def log_cost(self):
+        """
+        Log the current cost information.
+
+        Returns:
+            str: Formatted string of cost information
+        """
+        return self.cost_tracker.log()
+
+    def get_token_count(self, messages):
+        """
+        Get the token count for a list of messages.
+
+        Args:
+            messages: List of messages
+
+        Returns:
+            int: Token count
+        """
+        return litellm.token_counter(model=self.model, messages=messages)
+
+    def __str__(self):
+        return f"LLM(model={self.model}, base_url={self.base_url})"
+
+    def __repr__(self):
+        return str(self)
+
+
+# Example usage
+if __name__ == "__main__":
+    # Load environment variables if needed
+    from dotenv import load_dotenv
+
+    load_dotenv()
+
+    # Create LLM instance
+    llm = LLM()
+
+    # Test text completion
+    messages = llm.prepare_messages("Hello, how are you?")
+    response, cost, total_cost = llm.do_completion(messages=messages)
+    print(f"Response: {response['choices'][0]['message']['content']}")
+    print(f"Cost: ${cost:.6f}, Total cost: ${total_cost:.6f}")
+
+    # Test multimodal if image path is available
+    image_path = os.getenv("TEST_IMAGE_PATH")
+    if image_path and os.path.exists(image_path):
+        multimodal_response, mm_cost, mm_total_cost = llm.do_multimodal_completion(
+            "What's in this image?", image_path
+        )
+        print(
+            f"Multimodal response: {multimodal_response['choices'][0]['message']['content']}"
+        )
+        print(f"Cost: ${mm_cost:.6f}, Total cost: ${mm_total_cost:.6f}")

app/prompt/manus.py

@@ -10,5 +10,9 @@ BrowserUseTool: Open, browse, and use web browsers.If you open a local HTML file
 
 GoogleSearch: Perform web information retrieval
 
+Terminate: End the current interaction when the task is complete or when you need additional information from the user. Use this tool to signal that you've finished addressing the user's request or need clarification before proceeding further.
+
 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.
+
+Always maintain a helpful, informative tone throughout the interaction. If you encounter any limitations or need more details, clearly communicate this to the user before terminating.
 """

app/tool/browser_use_tool.py

@@ -12,6 +12,8 @@ from pydantic_core.core_schema import ValidationInfo
 from app.tool.base import BaseTool, ToolResult
 
 
+MAX_LENGTH = 2000
+
 _BROWSER_DESCRIPTION = """
 Interact with a web browser to perform various actions such as navigation, element interaction,
 content extraction, and tab management. Supported actions include:
@@ -180,7 +182,9 @@ class BrowserUseTool(BaseTool):
 
                 elif action == "get_html":
                     html = await context.get_page_html()
-                    truncated = html[:2000] + "..." if len(html) > 2000 else html
+                    truncated = (
+                        html[:MAX_LENGTH] + "..." if len(html) > MAX_LENGTH else html
+                    )
                     return ToolResult(output=truncated)
 
                 elif action == "get_text":

config/config.example.toml

@@ -1,7 +1,7 @@
 # Global LLM configuration
 [llm]
-model = "claude-3-5-sonnet"
-base_url = "https://api.openai.com/v1"
+model =  "gpt-4o" #"claude-3-5-sonnet"
+base_url = "https://api.openai.com/v1" # "https://api.anthropic.com"
 api_key = "sk-..."
 max_tokens = 4096
 temperature = 0.0
@@ -17,6 +17,6 @@ temperature = 0.0
 
 # Optional configuration for specific LLM models
 [llm.vision]
-model = "claude-3-5-sonnet"
-base_url = "https://api.openai.com/v1"
+model = "gpt-4o" # "claude-3-5-sonnet"
+base_url = "https://api.openai.com/v1" # "https://api.anthropic.com"
 api_key = "sk-..."

pytest.ini

@@ -1,14 +0,0 @@
-[pytest]
-testpaths = tests
-python_files = test_*.py
-python_classes = Test*
-python_functions = test_*
-
-# Log settings
-log_cli = true
-log_cli_level = INFO
-log_cli_format = %(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(lineno)s)
-log_cli_date_format = %Y-%m-%d %H:%M:%S
-
-# Make sure asyncio works properly
-asyncio_mode = auto

requirements.txt

@@ -20,3 +20,4 @@ aiofiles~=24.1.0
 pydantic_core~=2.27.2
 colorama~=0.4.6
 playwright~=1.49.1
+litellm~=1.63.6

run.bat

@@ -1,3 +0,0 @@
-@echo off
-venv\Scripts\python.exe app.py
-pause

static/main.js

@@ -1,307 +0,0 @@
-let currentEventSource = null;
-
-function createTask() {
-    const promptInput = document.getElementById('prompt-input');
-    const prompt = promptInput.value.trim();
-
-    if (!prompt) {
-        alert("Please enter a valid prompt");
-        promptInput.focus();
-        return;
-    }
-
-    if (currentEventSource) {
-        currentEventSource.close();
-        currentEventSource = null;
-    }
-
-    const container = document.getElementById('task-container');
-    container.innerHTML = '<div class="loading">Initializing task...</div>';
-    document.getElementById('input-container').classList.add('bottom');
-
-    fetch('/tasks', {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json'
-        },
-        body: JSON.stringify({ prompt })
-    })
-    .then(response => {
-        if (!response.ok) {
-            return response.json().then(err => { throw new Error(err.detail || 'Request failed') });
-        }
-        return response.json();
-    })
-    .then(data => {
-        if (!data.task_id) {
-            throw new Error('Invalid task ID');
-        }
-        setupSSE(data.task_id);
-        loadHistory();
-    })
-    .catch(error => {
-        container.innerHTML = `<div class="error">Error: ${error.message}</div>`;
-        console.error('Failed to create task:', error);
-    });
-}
-
-function setupSSE(taskId) {
-    let retryCount = 0;
-    const maxRetries = 3;
-    const retryDelay = 2000;
-
-    const container = document.getElementById('task-container');
-
-    function connect() {
-        const eventSource = new EventSource(`/tasks/${taskId}/events`);
-        currentEventSource = eventSource;
-
-        let heartbeatTimer = setInterval(() => {
-            container.innerHTML += '<div class="ping">·</div>';
-        }, 5000);
-
-        const pollInterval = setInterval(() => {
-            fetch(`/tasks/${taskId}`)
-                .then(response => response.json())
-                .then(task => {
-                    updateTaskStatus(task);
-                })
-                .catch(error => {
-                    console.error('Polling failed:', error);
-                });
-        }, 10000);
-
-        const handleEvent = (event, type) => {
-            clearInterval(heartbeatTimer);
-            try {
-                const data = JSON.parse(event.data);
-                container.querySelector('.loading')?.remove();
-                container.classList.add('active');
-
-                const stepContainer = ensureStepContainer(container);
-                const { formattedContent, timestamp } = formatStepContent(data, type);
-                const step = createStepElement(type, formattedContent, timestamp);
-
-                stepContainer.appendChild(step);
-                autoScroll(stepContainer);
-
-                fetch(`/tasks/${taskId}`)
-                    .then(response => response.json())
-                    .then(task => {
-                        updateTaskStatus(task);
-                    })
-                    .catch(error => {
-                        console.error('Status update failed:', error);
-                    });
-            } catch (e) {
-                console.error(`Error handling ${type} event:`, e);
-            }
-        };
-
-        const eventTypes = ['think', 'tool', 'act', 'log', 'run', 'message'];
-        eventTypes.forEach(type => {
-            eventSource.addEventListener(type, (event) => handleEvent(event, type));
-        });
-
-        eventSource.addEventListener('complete', (event) => {
-            clearInterval(heartbeatTimer);
-            clearInterval(pollInterval);
-            container.innerHTML += `
-                <div class="complete">
-                    <div>✅ Task completed</div>
-                    <pre>${lastResultContent}</pre>
-                </div>
-            `;
-            eventSource.close();
-            currentEventSource = null;
-        });
-
-        eventSource.addEventListener('error', (event) => {
-            clearInterval(heartbeatTimer);
-            clearInterval(pollInterval);
-            try {
-                const data = JSON.parse(event.data);
-                container.innerHTML += `
-                    <div class="error">
-                        ❌ Error: ${data.message}
-                    </div>
-                `;
-                eventSource.close();
-                currentEventSource = null;
-            } catch (e) {
-                console.error('Error handling failed:', e);
-            }
-        });
-
-        eventSource.onerror = (err) => {
-            if (eventSource.readyState === EventSource.CLOSED) return;
-
-            console.error('SSE connection error:', err);
-            clearInterval(heartbeatTimer);
-            clearInterval(pollInterval);
-            eventSource.close();
-
-            if (retryCount < maxRetries) {
-                retryCount++;
-                container.innerHTML += `
-                    <div class="warning">
-                        ⚠ Connection lost, retrying in ${retryDelay/1000} seconds (${retryCount}/${maxRetries})...
-                    </div>
-                `;
-                setTimeout(connect, retryDelay);
-            } else {
-                container.innerHTML += `
-                    <div class="error">
-                        ⚠ Connection lost, please try refreshing the page
-                    </div>
-                `;
-            }
-        };
-    }
-
-    connect();
-}
-
-function loadHistory() {
-    fetch('/tasks')
-    .then(response => {
-        if (!response.ok) {
-            return response.text().then(text => {
-                throw new Error(`请求失败: ${response.status} - ${text.substring(0, 100)}`);
-            });
-        }
-        return response.json();
-    })
-    .then(tasks => {
-        const listContainer = document.getElementById('task-list');
-        listContainer.innerHTML = tasks.map(task => `
-            <div class="task-card" data-task-id="${task.id}">
-                <div>${task.prompt}</div>
-                <div class="task-meta">
-                    ${new Date(task.created_at).toLocaleString()} -
-                    <span class="status status-${task.status ? task.status.toLowerCase() : 'unknown'}">
-                        ${task.status || '未知状态'}
-                    </span>
-                </div>
-            </div>
-        `).join('');
-    })
-    .catch(error => {
-        console.error('加载历史记录失败:', error);
-        const listContainer = document.getElementById('task-list');
-        listContainer.innerHTML = `<div class="error">加载失败: ${error.message}</div>`;
-    });
-}
-
-
-function ensureStepContainer(container) {
-    let stepContainer = container.querySelector('.step-container');
-    if (!stepContainer) {
-        container.innerHTML = '<div class="step-container"></div>';
-        stepContainer = container.querySelector('.step-container');
-    }
-    return stepContainer;
-}
-
-function formatStepContent(data, eventType) {
-    return {
-        formattedContent: data.result,
-        timestamp: new Date().toLocaleTimeString()
-    };
-}
-
-function createStepElement(type, content, timestamp) {
-    const step = document.createElement('div');
-    step.className = `step-item ${type}`;
-    step.innerHTML = `
-        <div class="log-line">
-            <span class="log-prefix">${getEventIcon(type)} [${timestamp}] ${getEventLabel(type)}:</span>
-            <pre>${content}</pre>
-        </div>
-    `;
-    return step;
-}
-
-function autoScroll(element) {
-    requestAnimationFrame(() => {
-        element.scrollTo({
-            top: element.scrollHeight,
-            behavior: 'smooth'
-        });
-    });
-    setTimeout(() => {
-        element.scrollTop = element.scrollHeight;
-    }, 100);
-}
-
-
-function getEventIcon(eventType) {
-    const icons = {
-        'think': '🤔',
-        'tool': '🛠️',
-        'act': '🚀',
-        'result': '🏁',
-        'error': '❌',
-        'complete': '✅',
-        'log': '📝',
-        'run': '⚙️'
-    };
-    return icons[eventType] || 'ℹ️';
-}
-
-function getEventLabel(eventType) {
-    const labels = {
-        'think': 'Thinking',
-        'tool': 'Using Tool',
-        'act': 'Action',
-        'result': 'Result',
-        'error': 'Error',
-        'complete': 'Complete',
-        'log': 'Log',
-        'run': 'Running'
-    };
-    return labels[eventType] || 'Info';
-}
-
-function updateTaskStatus(task) {
-    const statusBar = document.getElementById('status-bar');
-    if (!statusBar) return;
-
-    if (task.status === 'completed') {
-        statusBar.innerHTML = `<span class="status-complete">✅ Task completed</span>`;
-    } else if (task.status === 'failed') {
-        statusBar.innerHTML = `<span class="status-error">❌ Task failed: ${task.error || 'Unknown error'}</span>`;
-    } else {
-        statusBar.innerHTML = `<span class="status-running">⚙️ Task running: ${task.status}</span>`;
-    }
-}
-
-document.addEventListener('DOMContentLoaded', () => {
-    loadHistory();
-
-    document.getElementById('prompt-input').addEventListener('keydown', (e) => {
-        if (e.key === 'Enter' && !e.shiftKey) {
-            e.preventDefault();
-            createTask();
-        }
-    });
-
-    const historyToggle = document.getElementById('history-toggle');
-    if (historyToggle) {
-        historyToggle.addEventListener('click', () => {
-            const historyPanel = document.getElementById('history-panel');
-            if (historyPanel) {
-                historyPanel.classList.toggle('open');
-                historyToggle.classList.toggle('active');
-            }
-        });
-    }
-
-    const clearButton = document.getElementById('clear-btn');
-    if (clearButton) {
-        clearButton.addEventListener('click', () => {
-            document.getElementById('prompt-input').value = '';
-            document.getElementById('prompt-input').focus();
-        });
-    }
-});

static/style.css

@@ -1,353 +0,0 @@
-:root {
-    --primary-color: #007bff;
-    --primary-hover: #0056b3;
-    --success-color: #28a745;
-    --error-color: #dc3545;
-    --warning-color: #ff9800;
-    --info-color: #2196f3;
-    --text-color: #333;
-    --text-light: #666;
-    --bg-color: #f8f9fa;
-    --border-color: #ddd;
-}
-
-* {
-    box-sizing: border-box;
-    margin: 0;
-    padding: 0;
-}
-
-body {
-    font-family: 'PingFang SC', 'Microsoft YaHei', sans-serif;
-    margin: 0;
-    padding: 0;
-    background-color: var(--bg-color);
-    color: var(--text-color);
-}
-
-.container {
-    display: flex;
-    min-height: 100vh;
-    min-width: 0;
-    width: 90%;
-    margin: 0 auto;
-    padding: 20px;
-    gap: 20px;
-}
-
-.card {
-    background-color: white;
-    border-radius: 8px;
-    padding: 20px;
-    box-shadow: 0 2px 8px rgba(0,0,0,0.1);
-}
-
-.history-panel {
-    width: 300px;
-}
-
-.main-panel {
-    flex: 1;
-    display: flex;
-    flex-direction: column;
-    gap: 20px;
-}
-
-.task-list {
-    margin-top: 10px;
-    max-height: calc(100vh - 160px);
-    overflow-y: auto;
-    overflow-x: hidden;
-}
-
-.task-container {
-    @extend .card;
-    width: 100%;
-    max-width: 100%;
-    position: relative;
-    min-height: 300px;
-    display: flex;
-    flex-direction: column;
-    justify-content: center;
-    align-items: center;
-    overflow: auto;
-    height: 100%;
-}
-
-.welcome-message {
-    display: flex;
-    flex-direction: column;
-    justify-content: center;
-    align-items: center;
-    text-align: center;
-    color: var(--text-light);
-    background: white;
-    z-index: 1;
-    padding: 20px;
-    border-radius: 8px;
-    box-shadow: 0 2px 8px rgba(0,0,0,0.1);
-    width: 100%;
-    height: 100%;
-}
-
-.welcome-message h1 {
-    font-size: 2rem;
-    margin-bottom: 10px;
-    color: var(--text-color);
-}
-
-.input-container {
-    @extend .card;
-    display: flex;
-    gap: 10px;
-}
-
-#prompt-input {
-    flex: 1;
-    padding: 12px;
-    border: 1px solid #ddd;
-    border-radius: 4px;
-    font-size: 1rem;
-}
-
-button {
-    padding: 12px 24px;
-    background-color: var(--primary-color);
-    color: white;
-    border: none;
-    border-radius: 4px;
-    cursor: pointer;
-    font-size: 1rem;
-    transition: background-color 0.2s;
-}
-
-button:hover {
-    background-color: var(--primary-hover);
-}
-
-.task-item {
-    padding: 10px;
-    margin-bottom: 10px;
-    background-color: #f8f9fa;
-    border-radius: 4px;
-    cursor: pointer;
-    transition: background-color 0.2s;
-}
-
-.task-item:hover {
-    background-color: #e9ecef;
-}
-
-.task-item.active {
-    background-color: var(--primary-color);
-    color: white;
-}
-
-#input-container.bottom {
-    margin-top: auto;
-}
-
-.task-card {
-    background: #fff;
-    padding: 15px;
-    margin-bottom: 10px;
-    border-radius: 8px;
-    cursor: pointer;
-    transition: all 0.2s;
-}
-
-.task-card:hover {
-    transform: translateX(5px);
-    box-shadow: 0 2px 8px rgba(0,0,0,0.1);
-}
-
-.status-pending {
-    color: var(--text-light);
-}
-
-.status-running {
-    color: var(--primary-color);
-}
-
-.status-completed {
-    color: var(--success-color);
-}
-
-.status-failed {
-    color: var(--error-color);
-}
-
-.step-container {
-    display: flex;
-    flex-direction: column;
-    gap: 10px;
-    padding: 15px;
-    width: 100%;
-    max-height: calc(100vh - 200px);
-    overflow-y: auto;
-    max-width: 100%;
-    overflow-x: hidden;
-}
-
-.step-item {
-    padding: 15px;
-    background: white;
-    border-radius: 8px;
-    width: 100%;
-    box-shadow: 0 2px 4px rgba(0,0,0,0.05);
-    margin-bottom: 10px;
-    opacity: 1;
-    transform: none;
-}
-
-.step-item .log-line:not(.result) {
-    opacity: 0.7;
-    color: #666;
-    font-size: 0.9em;
-}
-
-.step-item .log-line.result {
-    opacity: 1;
-    color: #333;
-    font-size: 1em;
-    background: #e8f5e9;
-    border-left: 4px solid #4caf50;
-    padding: 10px;
-    border-radius: 4px;
-}
-
-.step-item.show {
-    opacity: 1;
-    transform: none;
-}
-
-.log-line {
-    padding: 10px;
-    border-radius: 4px;
-    margin-bottom: 10px;
-    display: flex;
-    flex-direction: column;
-    gap: 4px;
-}
-
-.log-line.think,
-.step-item pre.think {
-    background: var(--info-color-light);
-    border-left: 4px solid var(--info-color);
-}
-
-.log-line.tool,
-.step-item pre.tool {
-    background: var(--warning-color-light);
-    border-left: 4px solid var(--warning-color);
-}
-
-.log-line.result,
-.step-item pre.result {
-    background: var(--success-color-light);
-    border-left: 4px solid var(--success-color);
-}
-
-.log-line.error,
-.step-item pre.error {
-    background: var(--error-color-light);
-    border-left: 4px solid var(--error-color);
-}
-
-.log-line.info,
-.step-item pre.info {
-    background: var(--bg-color);
-    border-left: 4px solid var(--text-light);
-}
-
-.log-prefix {
-    font-weight: bold;
-    white-space: nowrap;
-    margin-bottom: 5px;
-    color: #666;
-}
-
-.step-item pre {
-    padding: 10px;
-    border-radius: 4px;
-    margin: 10px 0;
-    overflow-x: hidden;
-    font-family: 'Courier New', monospace;
-    font-size: 0.9em;
-    line-height: 1.4;
-    white-space: pre-wrap;
-    word-wrap: break-word;
-    word-break: break-all;
-    max-width: 100%;
-    color: var(--text-color);
-    background: var(--bg-color);
-
-    &.log {
-        background: var(--bg-color);
-        border-left: 4px solid var(--text-light);
-    }
-    &.think {
-        background: var(--info-color-light);
-        border-left: 4px solid var(--info-color);
-    }
-    &.tool {
-        background: var(--warning-color-light);
-        border-left: 4px solid var(--warning-color);
-    }
-    &.result {
-        background: var(--success-color-light);
-        border-left: 4px solid var(--success-color);
-    }
-}
-
-.step-item strong {
-    display: block;
-    margin-bottom: 8px;
-    color: #007bff;
-    font-size: 0.9em;
-}
-
-.step-item div {
-    color: #444;
-    line-height: 1.6;
-}
-
-.loading {
-    padding: 15px;
-    color: #666;
-    text-align: center;
-}
-
-.ping {
-    color: #ccc;
-    text-align: center;
-    margin: 5px 0;
-}
-
-.error {
-    color: #dc3545;
-    padding: 10px;
-    background: #ffe6e6;
-    border-radius: 4px;
-    margin: 10px 0;
-}
-
-.complete {
-    color: #28a745;
-    padding: 10px;
-    background: #e6ffe6;
-    border-radius: 4px;
-    margin: 10px 0;
-}
-
-pre {
-    margin: 0;
-    white-space: pre-wrap;
-    word-break: break-word;
-}
-
-.complete pre {
-    max-width: 100%;
-    white-space: pre-wrap;
-    word-break: break-word;
-}

templates/index.html

@@ -1,39 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>OpenManus Local Version</title>
-    <link rel="stylesheet" href="/static/style.css">
-</head>
-<body>
-    <div class="container">
-        <div class="history-panel">
-            <h2>History Tasks</h2>
-            <div id="task-list" class="task-list"></div>
-        </div>
-
-        <div class="main-panel">
-            <div id="task-container" class="task-container">
-                <div class="welcome-message">
-                    <h1>Welcome to OpenManus Local Version</h1>
-                    <p>Please enter a task prompt to start a new task</p>
-                </div>
-                <div id="log-container" class="step-container"></div>
-            </div>
-
-            <div id="input-container" class="input-container">
-                <input
-                    type="text"
-                    id="prompt-input"
-                    placeholder="Enter task prompt..."
-                    onkeypress="if(event.keyCode === 13) createTask()"
-                >
-                <button onclick="createTask()">Create Task</button>
-            </div>
-        </div>
-    </div>
-
-    <script src="/static/main.js"></script>
-</body>
-</html>