deep-agent-cli 1.0.0__py3-none-any.whl

app/core/LLM/__init__.py

@@ -0,0 +1,3 @@
+from app.core.LLM.factory import LLMFactory, LLMConfig
+
+__all__ = ["LLMFactory", "LLMConfig"]

app/core/LLM/anthropic_provider.py

@@ -0,0 +1,10 @@
+from langchain_anthropic import ChatAnthropic
+from typing import Any, Dict, Optional
+
+def create_anthropic_model(model_name: str, temperature: float, api_key: Optional[str], **extra_params: Any) -> ChatAnthropic:
+    return ChatAnthropic(
+        model=model_name,
+        temperature=temperature,
+        anthropic_api_key=api_key,
+        **extra_params
+    )

app/core/LLM/factory.py

@@ -0,0 +1,74 @@
+from typing import Optional, Dict, Any
+from pydantic import BaseModel, Field
+from langchain_core.language_models.chat_models import BaseChatModel
+
+class LLMConfig(BaseModel):
+    """Cấu hình cho việc khởi tạo LLM."""
+    provider: str = Field(..., description="Nhà cung cấp (openai, anthropic, google, ollama, etc.)")
+    model_name: str = Field(..., description="Tên model cụ thể (gpt-4, claude-3, gemini-pro, etc.)")
+    temperature: float = Field(default=0, description="Độ sáng tạo của model (0-1)")
+    api_key: Optional[str] = Field(None, description="API Key nếu cần thiết")
+    base_url: Optional[str] = Field(None, description="Base URL cho các provider như Ollama hoặc Local LLMs")
+    extra_params: Dict[str, Any] = Field(default_factory=dict, description="Các tham số bổ sung khác")
+
+class LLMFactory:
+    """
+    Factory class để quản lý việc khởi tạo các LLM từ nhiều nhà cung cấp khác nhau.
+    Logic khởi tạo cụ thể được tách ra các file provider riêng biệt.
+    """
+
+    @staticmethod
+    def create_llm(config: LLMConfig) -> BaseChatModel:
+        """
+        Khởi tạo và trả về một instance chuẩn của BaseChatModel.
+        Sử dụng Lazy Import để tránh lỗi khi thiếu thư viện của các provider không dùng tới.
+        """
+        provider = config.provider.lower()
+
+        try:
+            if provider == "openai":
+                from app.core.LLM.openai_provider import create_openai_model
+                return create_openai_model(
+                    model_name=config.model_name,
+                    temperature=config.temperature,
+                    api_key=config.api_key,
+                    **config.extra_params
+                )
+
+            elif provider == "anthropic":
+                from app.core.LLM.anthropic_provider import create_anthropic_model
+                return create_anthropic_model(
+                    model_name=config.model_name,
+                    temperature=config.temperature,
+                    api_key=config.api_key,
+                    **config.extra_params
+                )
+
+            elif provider == "google":
+                from app.core.LLM.google_provider import create_google_model
+                return create_google_model(
+                    model_name=config.model_name,
+                    temperature=config.temperature,
+                    api_key=config.api_key,
+                    **config.extra_params
+                )
+
+            elif provider == "ollama":
+                from app.core.LLM.ollama_provider import create_ollama_model
+                return create_ollama_model(
+                    model_name=config.model_name,
+                    temperature=config.temperature,
+                    base_url=config.base_url,
+                    **config.extra_params
+                )
+
+            else:
+                raise ValueError(f"Provider '{provider}' hiện chưa được hỗ trợ bởi Factory.")
+
+        except ImportError as e:
+            raise ImportError(
+                f"Lỗi: Thiếu thư viện cho provider '{provider}' hoặc lỗi cấu trúc file. "
+                f"Chi tiết: {str(e)}"
+            )
+        except Exception as e:
+            raise Exception(f"Lỗi hệ thống khi khởi tạo LLM ({provider}): {str(e)}")

app/core/LLM/google_provider.py

@@ -0,0 +1,19 @@
+import os
+from typing import Optional, Any
+
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+
+def create_google_model(model_name: str, temperature: float, api_key: Optional[str],
+                        **extra_params: Any) -> ChatGoogleGenerativeAI:
+    """
+    Khởi tạo và trả về instance ChatGoogleGenerativeAI.
+    """
+    if os.getenv("GOOGLE_API_KEY") is None and api_key:
+        os.environ["GOOGLE_API_KEY"] = api_key
+        
+    return ChatGoogleGenerativeAI(
+        model=model_name,
+        temperature=temperature,
+        **extra_params
+    )

app/core/LLM/ollama_provider.py

@@ -0,0 +1,12 @@
+from langchain_ollama.chat_models import ChatOllama
+from typing import Any, Dict, Optional
+
+
+def create_ollama_model(model_name: str, temperature: float, base_url: Optional[str],
+                        **extra_params: Any) -> ChatOllama:
+    return ChatOllama(
+        model=model_name,
+        temperature=temperature,
+        base_url=base_url,
+        **extra_params
+    )

app/core/LLM/openai_provider.py

@@ -0,0 +1,10 @@
+from langchain_openai import ChatOpenAI
+from typing import Any, Dict, Optional
+
+def create_openai_model(model_name: str, temperature: float, api_key: Optional[str], **extra_params: Any) -> ChatOpenAI:
+    return ChatOpenAI(
+        model=model_name,
+        temperature=temperature,
+        api_key=api_key,
+        **extra_params
+    )

app/core/__init__.py

@@ -0,0 +1,4 @@
+from app.core.agent.deep_agent import DeepAgentFactory
+from app.core.LLM.factory import LLMFactory, LLMConfig
+
+__all__ = ["LLMFactory", "LLMConfig", "DeepAgentFactory"]

app/core/agent/__init__.py

@@ -0,0 +1,3 @@
+from app.core.agent.deep_agent import DeepAgentFactory, DeepAgentConfig
+
+__all__ = ['DeepAgentFactory', 'DeepAgentConfig']

app/core/agent/deep_agent.py

@@ -0,0 +1,109 @@
+import os
+
+import yaml
+from typing import Any, Optional, Dict
+from pydantic import BaseModel, Field
+from deepagents import create_deep_agent, SubAgent
+from deepagents.backends import FilesystemBackend
+
+from app.core.LLM import LLMFactory, LLMConfig
+from app.core.checkpoint import CheckpointFactory, CheckpointConfig
+
+
+class DeepAgentConfig(BaseModel):
+    """Cấu hình toàn diện cho việc khởi tạo DeepAgent, hỗ trợ mở rộng các thuộc tính khác sau này."""
+    subagent_config_path: str = Field(default="config/subagent.yml",
+                                      description="Đường dẫn tới file config của subagent")
+    llm_config: LLMConfig = Field(..., description="Cấu hình LLM cho agent")
+    checkpoint_config: Optional[CheckpointConfig] = Field(default=None, description="Cấu hình checkpointer cho agent")
+    extra_params: Dict[str, Any] = Field(default_factory=dict,
+                                         description="Các thuộc tính cấu hình mở rộng khác trong tương lai")
+
+
+# from core.tools import ReadFileTool, WriteFileTool, ShellExecuteTool
+
+
+class DeepAgentFactory:
+    agent: dict = {}
+
+    config: dict = None
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def load_subagents(config_path: str = "config/v1/subagent.yml") -> list[SubAgent]:
+        with open(config_path) as f:
+            config = yaml.safe_load(f)
+
+        sub_agents = []
+        for name, spec in config.items():
+            subagent = SubAgent(
+                name=name,
+                description=spec["description"],
+                system_prompt=spec["system_prompt"],
+                interrupt_on=spec["interrupt_on"],
+            )
+            if "model" in spec:
+                subagent["model"] = spec["model"]
+
+            sub_agents.append(subagent)
+        return sub_agents
+
+    @staticmethod
+    def get_config(config_path: str = None) -> Any:
+        if DeepAgentFactory.config is None and isinstance(config_path, str):
+            actual_path = config_path
+            if not os.path.exists(actual_path):
+                # Fallback: tìm kiếm dựa trên thư mục cài đặt của package
+                # deep_agent.py nằm ở <package_root>/app/core/agent/deep_agent.py
+                current_dir = os.path.dirname(os.path.abspath(__file__))
+                package_root = os.path.dirname(os.path.dirname(os.path.dirname(current_dir)))
+                fallback_path = os.path.join(package_root, config_path.lstrip("/\\"))
+                if os.path.exists(fallback_path):
+                    actual_path = fallback_path
+
+            with open(actual_path, encoding="utf-8") as f:
+                config = yaml.safe_load(f)
+            DeepAgentFactory.config = config
+        return DeepAgentFactory.config
+
+    @staticmethod
+    def create_agent(
+            config_or_path: Any,
+            llm_config: Optional[LLMConfig] = None,
+            checkpoint_config: Optional[CheckpointConfig] = None
+    ):
+        """
+        Khởi tạo DeepAgent từ cấu hình.
+        Hỗ trợ nhận một instance DeepAgentConfig hoặc các tham số riêng lẻ (tương thích ngược).
+        """
+        if isinstance(config_or_path, DeepAgentConfig):
+            agent_config = config_or_path
+        else:
+            # Hỗ trợ tương thích ngược với cách gọi cũ
+            agent_config = DeepAgentConfig(
+                subagent_config_path=config_or_path,
+                llm_config=llm_config,
+                checkpoint_config=checkpoint_config
+            )
+
+        config = DeepAgentFactory.get_config(os.path.join(os.getenv("CONFIG_PATH", "config/v0"), "config.yml"))
+        model = LLMFactory.create_llm(agent_config.llm_config)
+        sub_agent = DeepAgentFactory.load_subagents(agent_config.subagent_config_path)
+
+        backend = FilesystemBackend(virtual_mode=True)
+        sys_prompt = config["system_prompt"]
+
+        checkpoint_cfg = agent_config.checkpoint_config or CheckpointConfig(provider="inmemory")
+        checkpointer = CheckpointFactory.create_checkpoint(checkpoint_cfg)
+
+        return create_deep_agent(
+            model=model,
+            subagents=sub_agent,
+            # tools=tools,
+            system_prompt=sys_prompt,
+            # permissions=permissions,
+            backend=backend,
+            checkpointer=checkpointer,
+        )

app/core/checkpoint/__init__.py

@@ -0,0 +1,3 @@
+from app.core.checkpoint.factory import CheckpointConfig, CheckpointFactory
+
+__all__ = ["CheckpointConfig", "CheckpointFactory"]

app/core/checkpoint/factory.py

@@ -0,0 +1,54 @@
+from typing import Optional, Dict, Any
+from pydantic import BaseModel, Field
+from langgraph.checkpoint.base import BaseCheckpointSaver
+
+class CheckpointConfig(BaseModel):
+    """Cấu hình cho việc khởi tạo Checkpointer."""
+    provider: str = Field(..., description="Nhà cung cấp checkpoint ('inmemory' hoặc 'sqlite')")
+    database_path: Optional[str] = Field(default=None, description="Đường dẫn đến file cơ sở dữ liệu SQLite (bắt buộc nếu provider là sqlite)")
+    extra_params: Dict[str, Any] = Field(default_factory=dict, description="Các tham số bổ sung khác")
+
+class CheckpointFactory:
+    """
+    Factory class để quản lý việc khởi tạo các Checkpoint Savers từ nhiều nhà cung cấp khác nhau.
+    Chỉ cần hỗ trợ 'inmemory' và 'sqlite'.
+    """
+
+    @staticmethod
+    def create_checkpoint(config: CheckpointConfig) -> BaseCheckpointSaver:
+        """
+        Khởi tạo và trả về một checkpointer (BaseCheckpointSaver) tương ứng.
+        Sử dụng Lazy Import để tối ưu hiệu năng và tránh lỗi khi thiếu thư viện.
+        """
+        provider = config.provider.lower()
+
+        try:
+            if provider == "inmemory":
+                from langgraph.checkpoint.memory import MemorySaver
+                return MemorySaver(**config.extra_params)
+
+            elif provider == "sqlite":
+                if not config.database_path:
+                    raise ValueError("SQLite checkpointer yêu cầu 'database_path' trong cấu hình.")
+                
+                import sqlite3
+                from langgraph.checkpoint.sqlite import SqliteSaver
+                
+                # check_same_thread=False là cần thiết cho SQLite trong môi trường đa luồng của Python
+                conn = sqlite3.connect(
+                    config.database_path, 
+                    check_same_thread=False,
+                    **config.extra_params
+                )
+                return SqliteSaver(conn)
+
+            else:
+                raise ValueError(f"Provider '{provider}' hiện chưa được hỗ trợ bởi CheckpointFactory.")
+
+        except ImportError as e:
+            raise ImportError(
+                f"Lỗi: Thiếu thư viện cho provider '{provider}' hoặc lỗi cấu trúc file. "
+                f"Chi tiết: {str(e)}"
+            )
+        except Exception as e:
+            raise Exception(f"Lỗi hệ thống khi khởi tạo Checkpointer ({provider}): {str(e)}")

app/service/ChatService.py

@@ -0,0 +1,245 @@
+import os
+from typing import Any, Optional, Dict, List, Generator
+from langgraph.types import Command
+from app.service.ConfigService import ConfigService
+
+
+class ChatService:
+    """
+    Service quản lý các cuộc hội thoại chat với agent của ConfigService.
+    Xử lý stream luồng suy nghĩ bằng phương thức agent.stream, ngắt human_in_the_loop và lưu lịch sử chat.
+    Áp dụng mẫu thiết kế Singleton để đảm bảo tính nhất quán của trạng thái phiên chat.
+    """
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super(ChatService, cls).__new__(cls, *args, **kwargs)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+
+        # Lưu trữ trạng thái của các phiên hội thoại
+        # Cấu trúc: { thread_id: { "status": str, "pending_actions": list, "review_configs": list, "last_result": Any } }
+        self._sessions: Dict[str, Dict[str, Any]] = {}
+        self._initialized = True
+
+    def send_message(self, thread_id: str, message: str) -> Generator[Dict[str, Any], None, None]:
+        """
+        Gửi tin nhắn của người dùng đến Agent và stream luồng suy nghĩ.
+        Thực hiện kiểm tra lỗi đầu vào ngay lập tức và trả về một Generator sinh ra các chunk từ agent.stream.
+        Chunk cuối cùng được yield là kết quả tổng hợp của phiên.
+        """
+        agent = ConfigService().get_agent()
+        if agent is None:
+            raise ValueError("Không thể lấy Agent từ ConfigService")
+
+        def _stream_logic():
+            # Chuẩn bị dữ liệu đầu vào và cấu hình cho agent
+            input_data = {"messages": [{"role": "user", "content": message}]}
+            config = {"configurable": {"thread_id": thread_id}}
+
+            # Khởi tạo session nếu chưa tồn tại
+            if thread_id not in self._sessions:
+                self._sessions[thread_id] = {
+                    "status": "completed",
+                    "pending_actions": [],
+                    "review_configs": [],
+                    "last_result": None
+                }
+
+            # Thực thi agent.stream với cơ chế chống lỗi try-except
+            try:
+
+                for chunk in agent.stream(input_data, config=config, stream_mode="updates"):
+                    yield chunk
+            except Exception as e:
+                print(f"[ChatService Error] Loi khi stream agent: {e}")
+                raise e
+
+            # Lấy trạng thái mới nhất từ agent sau khi kết thúc stream
+            try:
+                state = agent.get_state(config=config)
+            except Exception as e:
+                print(f"[ChatService Error] Loi khi lay state cuoi cung: {e}")
+                raise e
+
+            self._sessions[thread_id]["last_result"] = state
+
+            # Trích xuất interrupts từ state
+            interrupts = []
+            if state and hasattr(state, "tasks"):
+                for task in state.tasks:
+                    if hasattr(task, "interrupts") and task.interrupts:
+                        interrupts.extend(task.interrupts)
+
+            if interrupts:
+                interrupt = interrupts[0]
+                pending_actions = []
+
+                # Trích xuất pending actions từ interrupt value
+                if hasattr(interrupt, "value") and isinstance(interrupt.value, dict):
+                    pending_actions = interrupt.value.get("action_requests", [])
+                elif isinstance(interrupt, dict):
+                    pending_actions = interrupt.get("action_requests", [])
+
+                self._sessions[thread_id]["status"] = "waiting_approval"
+                self._sessions[thread_id]["pending_actions"] = pending_actions
+
+                final_res = {
+                    "status": "waiting_approval",
+                    "pending_actions": pending_actions
+                }
+                yield final_res
+            else:
+                # Trích xuất nội dung tin nhắn phản hồi cuối cùng từ agent
+                response_content = ""
+                messages = []
+                if state and hasattr(state, "values") and isinstance(state.values, dict):
+                    messages = state.values.get("messages", [])
+
+                if messages:
+                    last_msg = messages[-1]
+                    if hasattr(last_msg, "content"):
+                        response_content = last_msg.content
+                    elif isinstance(last_msg, dict):
+                        response_content = last_msg.get("content", "")
+
+                self._sessions[thread_id]["status"] = "completed"
+                self._sessions[thread_id]["pending_actions"] = []
+
+                final_res = {
+                    "status": "completed",
+                    "response": response_content
+                }
+                yield final_res
+
+        return _stream_logic()
+
+    def handle_approval(self, thread_id: str, decisions: List[Dict[str, Any]]) -> Generator[Dict[str, Any], None, None]:
+        """
+        Xử lý quyết định phê duyệt (approve/reject) của người dùng đối với các tool call bị ngắt và stream phản hồi tiếp theo.
+        Thực hiện kiểm tra lỗi đầu vào ngay lập tức và trả về một Generator sinh ra các chunk từ agent.stream.
+        Chunk cuối cùng được yield là kết quả tổng hợp của phiên.
+        """
+        if thread_id not in self._sessions:
+            raise ValueError("Không tìm thấy phiên hội thoại")
+
+        session = self._sessions[thread_id]
+        if session.get("status") != "waiting_approval":
+            raise ValueError("Phiên hội thoại không ở trạng thái chờ duyệt")
+
+        agent = ConfigService().get_agent()
+        if agent is None:
+            raise ValueError("Không thể lấy Agent từ ConfigService")
+
+        def _stream_logic():
+            # Tạo command resume gửi cho agent
+            cmd = Command(resume={"decisions": decisions})
+            config = {"configurable": {"thread_id": thread_id}}
+
+            # Thực thi agent.stream tiếp tục với cơ chế chống lỗi try-except
+            try:
+                # stream_generator = agent.stream(cmd, config=config,stream_mode="values")
+                for chunk in agent.stream(cmd, config=config,stream_mode="updates"):
+                    yield chunk
+            except Exception as e:
+                print(f"[ChatService Error] Loi khi stream tiep tuc agent: {e}")
+                raise e
+
+            # Lấy trạng thái mới nhất từ agent sau khi kết thúc stream
+            try:
+                state = agent.get_state(config=config)
+            except Exception as e:
+                print(f"[ChatService Error] Loi khi lay state cuoi cung: {e}")
+                raise e
+
+            self._sessions[thread_id]["last_result"] = state
+
+            # Trích xuất interrupts từ state
+            interrupts = []
+            if state and hasattr(state, "tasks"):
+                for task in state.tasks:
+                    if hasattr(task, "interrupts") and task.interrupts:
+                        interrupts.extend(task.interrupts)
+
+            if interrupts:
+                interrupt = interrupts[0]
+                pending_actions = []
+                if hasattr(interrupt, "value") and isinstance(interrupt.value, dict):
+                    pending_actions = interrupt.value.get("action_requests", [])
+                elif isinstance(interrupt, dict):
+                    pending_actions = interrupt.get("action_requests", [])
+
+                self._sessions[thread_id]["status"] = "waiting_approval"
+                self._sessions[thread_id]["pending_actions"] = pending_actions
+
+                final_res = {
+                    "status": "waiting_approval",
+                    "pending_actions": pending_actions
+                }
+                yield final_res
+            else:
+                response_content = ""
+                messages = []
+                if state and hasattr(state, "values") and isinstance(state.values, dict):
+                    messages = state.values.get("messages", [])
+
+                if messages:
+                    last_msg = messages[-1]
+                    if hasattr(last_msg, "content"):
+                        response_content = last_msg.content
+                    elif isinstance(last_msg, dict):
+                        response_content = last_msg.get("content", "")
+
+                self._sessions[thread_id]["status"] = "completed"
+                self._sessions[thread_id]["pending_actions"] = []
+
+                final_res = {
+                    "status": "completed",
+                    "response": response_content
+                }
+                yield final_res
+
+        return _stream_logic()
+
+    def get_history(self, thread_id: str) -> list:
+        """
+        Lấy toàn bộ lịch sử tin nhắn của phiên hội thoại (thread_id) từ agent state.
+        """
+        agent = ConfigService().get_agent()
+        if agent is None:
+            raise ValueError("Không thể lấy Agent từ ConfigService")
+
+        # Truy xuất state hiện tại của agent với cơ chế chống lỗi try-except
+        try:
+            state = agent.get_state(config={"configurable": {"thread_id": thread_id}})
+        except Exception as e:
+            print(f"[ChatService Error] Loi khi lay lich su tu agent: {e}")
+            return []
+
+        if not state or not hasattr(state, "values") or not state.values:
+            return []
+
+        return state.values.get("messages", [])
+
+    def get_session_status(self, thread_id: str) -> Optional[str]:
+        """
+        Lấy trạng thái hiện tại của phiên hội thoại (thread_id).
+        """
+        session = self._sessions.get(thread_id)
+        if session:
+            return session.get("status")
+        return None
+
+    def get_pending_actions(self, thread_id: str) -> List[Dict[str, Any]]:
+        """
+        Lấy danh sách các action đang chờ duyệt của phiên hội thoại (thread_id).
+        """
+        session = self._sessions.get(thread_id)
+        if session:
+            return session.get("pending_actions", [])
+        return []