def add_cot(prompt: str) -> str:
    return prompt + "\n\nLet's think step by step."

import asyncio
from collections import Counter

async def self_consistent_answer(
    question: str, 
    n_samples: int = 5,
    temperature: float = 0.7
) -> str:
    
    cot_prompt = f"{question}\n\nLet's think step by step."
    
    # Sample n independent reasoning paths
    tasks = [
        llm.invoke(cot_prompt, temperature=temperature) 
        for _ in range(n_samples)
    ]
    responses = await asyncio.gather(*tasks)
    
    # Extract final answers
    answers = [extract_final_answer(r) for r in responses]
    
    # Majority vote
    most_common = Counter(answers).most_common(1)[0][0]
    return most_common

async def tree_of_thought(problem: str, breadth: int = 3, depth: int = 3):
    
    # Generate initial approaches
    approaches_prompt = f"""
Problem: {problem}

Generate {breadth} different high-level approaches to solve this.
Format: numbered list, one sentence each.
"""
    approaches_text = await llm.invoke(approaches_prompt)
    approaches = parse_numbered_list(approaches_text)
    
    best_path = None
    best_score = 0
    
    for approach in approaches:
        # Evaluate each approach
        eval_prompt = f"""
Problem: {problem}
Approach: {approach}

Rate this approach's likelihood of success (1-10) and explain why.
Format: SCORE: X\nREASON: ...
"""
        evaluation = await llm.invoke(eval_prompt)
        score = extract_score(evaluation)
        
        if score > best_score:
            best_score = score
            best_path = approach
    
    # Execute best path with CoT
    return await chain_of_thought_solve(problem, approach=best_path)

def build_rag_prompt(query: str, retrieved_chunks: list, 
                     min_score: float = 0.75) -> str:
    
    relevant = [c for c in retrieved_chunks if c.score >= min_score]
    
    if not relevant:
        return f"No relevant context found.\n\nQuestion: {query}"
    
    context_block = "\n\n".join([
        f"[Source {i+1} - score: {c.score:.2f}]\n{c.text}"
        for i, c in enumerate(relevant[:5])  # max 5 chunks
    ])
    
    return f"""CONTEXT:
{context_block}

Using only the above context, answer:
{query}

If the context doesn't contain the answer, say so explicitly."""

SYSTEM_PROMPT = """You are a financial analysis assistant.

CONSTITUTION:
1. Never make specific investment recommendations ("buy X" or "sell Y")
2. Always distinguish between historical data and forward projections
3. When citing statistics, mention the source and date if known
4. If asked about illegal activities, decline and explain why
5. Acknowledge uncertainty — avoid false confidence

STYLE:
- Be precise and data-driven
- Prefer tables and bullet points for comparative data
- Keep responses under 500 words unless detail is explicitly requested
"""

STRUCTURED_PROMPT = """Analyze the following customer feedback and extract:

REQUIRED OUTPUT FORMAT (strict JSON):
{
  "sentiment": "positive" | "negative" | "neutral",
  "topics": ["topic1", "topic2"],  // max 5
  "urgency": 1-5,  // 5 = immediate action needed
  "action_required": boolean,
  "suggested_action": "string or null if no action"
}

Rules:
- Return ONLY valid JSON, no prose
- urgency=5 only if customer threatens churn or legal action
- topics must be from: [billing, product, support, shipping, other]

FEEDBACK: {feedback_text}
"""

EXAMPLE = """
Input: "I've been waiting 3 weeks for my order and nobody responds to emails"
Output: {
  "sentiment": "negative",
  "topics": ["shipping", "support"],
  "urgency": 4,
  "action_required": true,
  "suggested_action": "Escalate to fulfillment team, send apology email with tracking"
}
"""

class PromptEvaluator:
    def __init__(self, test_cases: list[dict]):
        self.test_cases = test_cases  # [{input, expected_output}]
    
    async def evaluate(self, prompt_template: str) -> dict:
        results = []
        for case in self.test_cases:
            prompt = prompt_template.format(**case["input"])
            response = await llm.invoke(prompt)
            score = self.score_response(response, case["expected_output"])
            results.append(score)
        
        return {
            "mean_score": sum(results) / len(results),
            "pass_rate": sum(1 for r in results if r >= 0.8) / len(results),
            "samples": len(results)
        }
    
    def score_response(self, response: str, expected: str) -> float:
        # Use LLM-as-judge or exact match depending on task type
        return llm_judge_score(response, expected)