Chapter 7 — Planning & Reasoning

# Without CoT
prompt = "What is 27 * 43?"
# LLM might get it wrong

# With CoT
prompt = """What is 27 * 43? Think step by step.

Step 1: 27 * 40 = 1,080
Step 2: 27 * 3 = 81
Step 3: 1,080 + 81 = 1,161

The answer is 1,161."""

system_prompt = """You are a research assistant. For each step:

1. THINK: Explain your reasoning about what to do next
2. ACT: Call a tool if needed
3. OBSERVE: Analyze the tool's output
4. REPEAT until you can answer the user's question

Always show your thinking before acting."""

def plan_and_execute(goal: str):
    # Step 1: Generate a plan
    plan = llm.generate(f"""
    Create a step-by-step plan to achieve this goal: {goal}
    
    Output as a numbered list. Each step should be specific and actionable.
    """)
    
    steps = parse_plan(plan)
    results = []
    
    for i, step in enumerate(steps):
        # Step 2: Execute each step
        result = agent.execute(step)
        results.append(result)
        
        # Step 3: Check progress
        evaluation = llm.generate(f"""
        Goal: {goal}
        Completed steps: {results}
        Remaining steps: {steps[i+1:]}
        
        Is the plan still on track? Should we modify remaining steps?
        """)
        
        if "replan" in evaluation.lower():
            steps = replan(goal, results, steps[i+1:])
    
    return synthesize_answer(goal, results)

def reflexion_loop(task: str, max_retries: int = 3):
    reflections = []
    
    for attempt in range(max_retries):
        # Attempt the task (with past reflections as context)
        result = agent.execute(task, past_reflections=reflections)
        
        # Evaluate
        success = evaluate(result, task)
        if success:
            return result
        
        # Reflect on the failure
        reflection = llm.generate(f"""
        Task: {task}
        Attempt #{attempt + 1} failed.
        Result: {result}
        
        What went wrong? What should I do differently next time?
        Be specific and actionable.
        """)
        
        reflections.append(reflection)
    
    return "Failed after maximum retries."

def decompose_task(complex_task: str) -> list[str]:
    return llm.generate(f"""
    Break this complex task into 3-7 simple, independent sub-tasks:
    
    Task: {complex_task}
    
    Rules:
    - Each sub-task should be completable with a single tool call
    - Sub-tasks should be ordered by dependency
    - Include a final "verify" sub-task
    
    Output as a JSON array of strings.
    """)

# Example
subtasks = decompose_task("Create a data analysis report on Q4 sales")
# ["Search for Q4 sales data files",
#  "Load and clean the sales data",
#  "Calculate key metrics (total revenue, growth rate, top products)", 
#  "Generate visualizations (bar chart, trend line)",
#  "Write the report narrative",
#  "Format as PDF with charts embedded",
#  "Verify all numbers match the source data"]