Planning and Reasoning

// Chain-of-Thought with structured prompting
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

async function chainOfThought(question: string): Promise<string> {
  const response = await client.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 2048,
    system: `You are an analytical reasoning agent. When solving problems:

1. First, identify the key components of the problem
2. Break down the problem into clear steps
3. Work through each step showing your reasoning
4. Verify your answer before stating it
5. Provide a clear final answer

Format:
## Analysis
[Identify key components]

## Step-by-Step Reasoning
[Work through each step]

## Verification
[Check your work]

## Answer
[Final answer]`,
    messages: [{ role: "user", content: question }],
  });

  return response.content[0].type === "text" ? response.content[0].text : "";
}

// Zero-shot CoT (simplest form)
async function zeroShotCoT(question: string): Promise<string> {
  const response = await client.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 2048,
    messages: [
      {
        role: "user",
        content: `${question}\n\nLet's think through this step by step.`,
      },
    ],
  });

  return response.content[0].type === "text" ? response.content[0].text : "";
}

# Chain-of-Thought in Python
import anthropic

client = anthropic.Anthropic()

def chain_of_thought(question: str) -> str:
    """Use structured CoT prompting for complex reasoning."""
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        system="""You are an analytical reasoning agent. For every problem:
1. Identify the key components
2. Break down into clear steps
3. Show reasoning for each step
4. Verify your answer
5. Provide a clear final answer""",
        messages=[{"role": "user", "content": question}],
    )
    return response.content[0].text

# Few-shot CoT with examples
def few_shot_cot(question: str) -> str:
    """Use examples to demonstrate the reasoning pattern."""
    examples = """
Q: If a store has 3 shelves with 8 items each, and they remove 5 items, how many remain?
A: Let me think step by step.
- Start: 3 shelves x 8 items = 24 total items
- Remove: 24 - 5 = 19 items
- Answer: 19 items remain.

Q: A train travels 120km in 2 hours. If it speeds up by 50%, how long for 180km?
A: Let me think step by step.
- Original speed: 120km / 2h = 60 km/h
- New speed: 60 * 1.5 = 90 km/h
- Time for 180km: 180 / 90 = 2 hours
- Answer: 2 hours.
"""
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[
            {"role": "user", "content": f"{examples}\nQ: {question}\nA: Let me think step by step."}
        ],
    )
    return response.content[0].text

// Tree-of-Thought implementation
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

interface ThoughtNode {
  thought: string;
  score: number;
  children: ThoughtNode[];
}

async function treeOfThought(
  problem: string,
  breadth: number = 3,
  depth: number = 3
): Promise<string> {
  // Step 1: Generate multiple initial approaches
  const approaches = await generateThoughts(problem, breadth);

  // Step 2: Evaluate and score each approach
  const scoredApproaches = await evaluateThoughts(problem, approaches);

  // Step 3: Expand the top approaches
  const topApproaches = scoredApproaches
    .sort((a, b) => b.score - a.score)
    .slice(0, 2);

  let bestSolution = "";
  let bestScore = 0;

  for (const approach of topApproaches) {
    // Recursively expand promising branches
    const solution = await expandThought(problem, approach, depth - 1);
    if (solution.score > bestScore) {
      bestScore = solution.score;
      bestSolution = solution.thought;
    }
  }

  return bestSolution;
}

async function generateThoughts(
  problem: string,
  n: number
): Promise<string[]> {
  const response = await client.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 2048,
    messages: [
      {
        role: "user",
        content: `Problem: ${problem}

Generate exactly ${n} different approaches to solve this problem.
Format each as: APPROACH N: [description]
Be creative — each approach should be meaningfully different.`,
      },
    ],
  });

  const text = response.content[0].type === "text" ? response.content[0].text : "";
  return text.split(/APPROACH \d+:/).filter(Boolean).map(s => s.trim());
}

async function evaluateThoughts(
  problem: string,
  thoughts: string[]
): Promise<ThoughtNode[]> {
  const scored: ThoughtNode[] = [];

  for (const thought of thoughts) {
    const response = await client.messages.create({
      model: "claude-sonnet-4-20250514",
      max_tokens: 256,
      messages: [
        {
          role: "user",
          content: `Problem: ${problem}
Approach: ${thought}
Rate this approach from 1-10 for feasibility, correctness, and completeness.
Respond with just the number.`,
        },
      ],
    });

    const scoreText = response.content[0].type === "text" ? response.content[0].text : "5";
    const score = parseInt(scoreText.trim()) || 5;
    scored.push({ thought, score, children: [] });
  }

  return scored;
}

# Tree-of-Thought in Python
import anthropic
from dataclasses import dataclass

client = anthropic.Anthropic()

@dataclass
class ThoughtNode:
    thought: str
    score: float
    children: list

def tree_of_thought(problem: str, breadth: int = 3, depth: int = 3) -> str:
    # Generate multiple approaches
    approaches = generate_thoughts(problem, breadth)

    # Evaluate each approach
    scored = evaluate_thoughts(problem, approaches)

    # Expand the best approaches
    scored.sort(key=lambda x: x.score, reverse=True)
    top_approaches = scored[:2]

    best_solution = ""
    best_score = 0

    for approach in top_approaches:
        solution = expand_thought(problem, approach, depth - 1)
        if solution.score > best_score:
            best_score = solution.score
            best_solution = solution.thought

    return best_solution

def generate_thoughts(problem: str, n: int) -> list[str]:
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": f"""Problem: {problem}
Generate {n} different approaches to solve this. Format: APPROACH N: [description]"""
        }],
    )
    text = response.content[0].text
    return [s.strip() for s in text.split("APPROACH")[1:] if s.strip()]

def evaluate_thoughts(problem: str, thoughts: list[str]) -> list[ThoughtNode]:
    scored = []
    for thought in thoughts:
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=256,
            messages=[{
                "role": "user",
                "content": f"Problem: {problem}\nApproach: {thought}\nRate 1-10. Just the number."
            }],
        )
        score = int(response.content[0].text.strip())
        scored.append(ThoughtNode(thought=thought, score=score, children=[]))
    return scored

// Self-reflection pattern
async function reflectiveAgent(
  task: string,
  maxReflections: number = 3
): Promise<string> {
  let currentSolution = "";

  // Initial attempt
  const initialResponse = await client.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 2048,
    messages: [{ role: "user", content: task }],
  });
  currentSolution = initialResponse.content[0].type === "text"
    ? initialResponse.content[0].text : "";

  // Reflection loop
  for (let i = 0; i < maxReflections; i++) {
    // Critique the current solution
    const critique = await client.messages.create({
      model: "claude-sonnet-4-20250514",
      max_tokens: 1024,
      messages: [
        {
          role: "user",
          content: `Task: ${task}

Current solution:
${currentSolution}

Critically evaluate this solution. Identify:
1. Errors or inaccuracies
2. Missing information
3. Areas for improvement
4. Overall quality score (1-10)

If the score is 8 or above, respond with "APPROVED".
Otherwise, provide specific feedback for improvement.`,
        },
      ],
    });

    const critiqueText = critique.content[0].type === "text"
      ? critique.content[0].text : "";

    if (critiqueText.includes("APPROVED")) {
      return currentSolution;
    }

    // Revise based on feedback
    const revision = await client.messages.create({
      model: "claude-sonnet-4-20250514",
      max_tokens: 2048,
      messages: [
        {
          role: "user",
          content: `Task: ${task}

Previous solution:
${currentSolution}

Feedback:
${critiqueText}

Please revise the solution addressing all the feedback.`,
        },
      ],
    });

    currentSolution = revision.content[0].type === "text"
      ? revision.content[0].text : "";
  }

  return currentSolution;
}

# Iterative re-planning agent
import anthropic
import json

client = anthropic.Anthropic()

def replan_agent(task: str, max_replans: int = 3) -> str:
    # Create initial plan
    plan = create_plan(task)
    results = []
    replans = 0

    while plan and replans <= max_replans:
        step = plan.pop(0)

        # Execute the current step
        result = execute_step(step, results)
        results.append({"step": step, "result": result})

        # Check if re-planning is needed
        if should_replan(task, plan, results):
            plan = create_updated_plan(task, results, plan)
            replans += 1

    # Synthesize final answer
    return synthesize_results(task, results)

def create_plan(task: str) -> list[str]:
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": f"Create a step-by-step plan for: {task}\nReturn as JSON array of strings."
        }],
    )
    return json.loads(response.content[0].text)

def should_replan(task: str, remaining_plan: list, results: list) -> bool:
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=256,
        messages=[{
            "role": "user",
            "content": f"""Task: {task}
Completed: {json.dumps(results[-1] if results else {})}
Remaining plan: {json.dumps(remaining_plan)}
Should we adjust the plan? Answer YES or NO with brief reason."""
        }],
    )
    return "YES" in response.content[0].text.upper()