Agent Scheduler

# From agent_scheduler.py
scheduler_system_message = dedent("""Role: Enhanced Task Scheduler

Primary Responsibility:
The Enhanced Task Scheduler's main duty is to analyze user input, create a structured task plan 
based on available tools, and then select and call appropriate tools from the given set to fulfill 
user requirements.

Mode Selection Strategy:
- **Prioritize Web Search**: Before selecting a primary mode, determine if the user's query can be 
  directly answered using the `web_search` tool for real-time data, definitions, or general knowledge.
  
- **Repository Mode**: Use `run_repository_agent` for tasks involving code repositories. This unified 
  tool automatically detects whether the repository is a GitHub URL or local path. Triggered when:
  * User mentions local file paths, specific local directories
  * User wants to find existing solutions, mentions GitHub
  * User provides specific repository URLs or paths
  
- **General Code Assistant Mode**: Used for general programming questions, requests for code examples, 
  debugging help, or when no specific repository is mentioned.
""")

# From agent_scheduler.py
user_proxy_system_message = dedent("""Role: Execution Proxy (User Proxy)

Primary Rules:
- Do not provide user-facing answers.
- Never paraphrase or repeat content already provided by scheduler_agent.
- Summarize tool outputs succinctly for the scheduler_agent only when needed
- If your candidate message would substantially repeat the last two messages, send exactly "TERMINATE"
- After scheduler_agent has delivered the final complete answer, respond with exactly "TERMINATE"
""")

def initialize_agents(self, **kwargs):
    """Initialize scheduler agent and user agent."""
    self.scheduler = ExtendedAssistantAgent(
        name="scheduler_agent",
        system_message=scheduler_system_message,
        is_termination_msg=lambda x: x.get("content", "") and x.get("content", "").endswith("TERMINATE"),
        llm_config=self.llm_config,
    )

self.user_proxy = ExtendedUserProxyAgent(
    name="user_proxy",
    system_message=user_proxy_system_message,
    llm_config=self.llm_config,
    is_termination_msg=lambda x: x.get("content", "") and x.get("content", "").endswith("TERMINATE"),
    human_input_mode="NEVER",
    max_consecutive_auto_reply=10,
    code_execution_config=self.code_execution_config,
)

def register_tools(self):
    """Register the enhanced toolkit required by the agent."""
    register_toolkits(
        [
            self.web_search,                    # Web search mode
            self.run_repository_agent,          # Unified repository processing mode
            self.run_general_code_assistant,    # General code assistant mode
            self.github_repo_search,            # GitHub repository search
        ],
        self.scheduler,
        self.user_proxy,
    )

def solve_task_with_repo(self, task: str) -> str:
    """Main entry point for task solving"""
    initial_message = task
    
    # Start conversation
    chat_result = self.user_proxy.initiate_chat(
        self.scheduler,
        message=initial_message,
        max_turns=12,
        summary_method="reflection_with_llm",
        summary_args={
            'summary_prompt': "Summarize takeaway from the conversation and generate a complete and detailed report at last. Do not add any introductory phrases. The final answer should correspond to the user's question."
        }
    )
    
    final_answer = self._extract_final_answer(chat_result)
    return final_answer

def _extract_final_answer(self, chat_result) -> str:
    """Extract final answer from chat history"""
    final_answer = chat_result.summary
    
    if isinstance(final_answer, dict):
        final_answer = final_answer['content']
    
    if final_answer is None:
        final_answer = ""
    final_answer = final_answer.strip().lstrip()
    
    messages = chat_result.chat_history
    final_content = messages[-1].get("content", "")
    if final_content:
        final_content = final_content.strip().lstrip()
    
    if final_answer == "":
        final_answer = final_content
    
    return final_answer

from src.core.agent_scheduler import RepoMasterAgent
from configs.oai_config import get_llm_config

# Setup
llm_config = get_llm_config()
code_execution_config = {
    "work_dir": "/path/to/work/dir",
    "use_docker": False
}

# Initialize agent
repo_master = RepoMasterAgent(
    llm_config=llm_config,
    code_execution_config=code_execution_config
)

# Execute task - scheduler automatically selects appropriate mode
result = repo_master.solve_task_with_repo(
    "What is the stock price of APPLE?"
)
print(result)

# Task requiring repository exploration
result = repo_master.solve_task_with_repo(
    "Help me convert '/data/DeepResearcher.pdf' to markdown and save"
)

# Direct repository agent call
result = repo_master.run_repository_agent(
    task_description="Extract text from PDF",
    repository="https://github.com/spatie/pdf-to-text",
    input_data='[{"path": "input.pdf", "description": "PDF to process"}]'
)

# Direct general assistant call
result = repo_master.run_general_code_assistant(
    task_description="Write a function to merge CSV files",
    work_directory="/path/to/work"
)