Chapter 4: Reasoning

async function singleCallReport(topic: string) {
  const prompt = `
    You are a careful analyst.

    Task: Research "${topic}" and write a short report.
    Think step by step, identifying key questions
    and answering them.

    Then write the final report.
  `;

  const report = await llm.complete(prompt);
  return report;
}

async function multiCallReport(topic: string) {
  // Call 1: Decompose the problem
  const plan = await llm.complete(`
    You are planning research on "${topic}".

    List 3–5 concrete subquestions that,
    if answered, would give a good overview.
  `);

  const questions = parseQuestions(plan);

  // Call 2: Retrieve for each subquestion
  const findings = await Promise.all(
    questions.map(async (q) => {
      const results = await searchWeb(q); // external tool
      return { question: q, results };
    })
  );

  // Call 3: Synthesize from actual retrieved data
  const synthesis = await llm.complete(`
    You are writing a report on "${topic}".

    Here are subquestions and search results:

    ${findings
      .map(
        (f) =>
          `Question: ${f.question}\n` +
          f.results
            .map((r) => `Title: ${r.title}\nSnippet: ${r.snippet}`)
            .join('\n\n')
      )
      .join('\n\n---\n\n')}

    Based only on these results, write a concise report.
  `);

  return synthesis;
}

async function implementWithTests(spec: string) {
  // Call 1: Generate code
  const code = await llm.complete(`
    Implement the following specification in TypeScript:

    ${spec}
  `);

  // Intermediate: run actual tests on the code
  const results = await runTestsOnGeneratedCode(code);

  // Call 2: Fix based on real failures
  if (!results.allPassed) {
    const fixed = await llm.complete(`
      The following implementation failed tests:

      ${code}

      Test results:
      ${formatTestResults(results)}

      Fix the code so all tests pass.
    `);
    return fixed;
  }

  return code;
}

async function singleCallImplementAndEvaluate() {
  const response = await llm.complete(`
    Write a TypeScript function \`quicksort\` that sorts an array in-place.

    After you write the code, evaluate it carefully:
    - Is it a correct quicksort?
    - Does it sort in-place?
    - What edge cases might fail?

    First write the code, then the evaluation.
  `);

  return response;
}

async function multiCallImplementAndEvaluate() {
  // Call 1: generate code
  const code = await llm.complete(`
    Write a TypeScript function \`quicksort\` that sorts an array in-place.
  `);

  // Call 2: evaluate as a fresh reviewer
  const evaluation = await llm.complete(`
    You are a strict code reviewer.

    Here is a quicksort implementation:

    ${code}

    Evaluate it critically:
    - Is it a correct quicksort?
    - Does it sort in-place?
    - What edge cases or bugs do you see?
    - How would you improve it?

    Be direct and specific.
  `);

  return { code, evaluation };
}

async function improveInPlace(concept: string) {
  const response = await llm.complete(`
    Explain "${concept}" to a junior engineer.
    Then improve your explanation to make it clearer.
  `);

  return response;
}

async function generateThenRevise(concept: string) {
  // Step 1: draft
  const draft = await llm.complete(`
    Explain "${concept}" to a junior engineer
    in 3–4 paragraphs.
  `);

  // Step 2: feedback
  const feedback = await llm.complete(`
    You are reviewing an explanation for a junior engineer.

    Explanation:
    ${draft}

    Identify concrete issues:
    - What parts are confusing?
    - What important details are missing?
    - Where could examples help?

    List specific suggestions, not general advice.
  `);

  // Step 3: revision
  const revision = await llm.complete(`
    Here is your original explanation:

    ${draft}

    Here is feedback on it:

    ${feedback}

    Rewrite the explanation to address the feedback
    while keeping it roughly the same length.
  `);

  return { draft, feedback, revision };
}

async function generateEvaluateRevise(task: string) {
  // Generate
  const draft = await llm.complete(task);

  // Evaluate (separate call, structured feedback)
  const evaluation = await llm.complete(`
    You are a critical evaluator.

    Task:
    ${task}

    Draft:
    ${draft}

    Identify problems with this draft:
    - Incorrect or misleading statements
    - Missing important points
    - Unclear explanations or poor structure

    Be specific and actionable.
  `);

  // Optionally decide if revision is needed…

  // Revise
  const revised = await llm.complete(`
    Task:
    ${task}

    Original draft:
    ${draft}

    Evaluation of the draft:
    ${evaluation}

    Produce a revised version that fixes the issues.
  `);

  return { draft, evaluation, revised };
}

async function refineUntilGoodEnough(task: string, maxRounds = 3) {
  let current = await llm.complete(task);

  for (let round = 0; round < maxRounds; round++) {
    const evaluation = await llm.complete(`
      You are evaluating this response:

      Task:
      ${task}

      Response:
      ${current}

      Score it from 1–10 on:
      - Correctness
      - Completeness
      - Clarity

      Then list specific improvements.
    `);

    const { score, suggestions } = parseEvaluation(evaluation);

    if (score >= 8) break; // good enough

    current = await llm.complete(`
      Task:
      ${task}

      Current response:
      ${current}

      Suggested improvements:
      ${suggestions}

      Rewrite the response to address the suggestions.
    `);
  }

  return current;
}

async function generateAndSelect(task: string, n = 5) {
  // Generate N candidates
  const candidates = await Promise.all(
    Array.from({ length: n }, () => llm.complete(task))
  );

  // Evaluate each candidate independently
  const evaluations = await Promise.all(
    candidates.map((candidate) =>
      llm.complete(`
        Task:
        ${task}

        Candidate response:
        ${candidate}

        Score from 1–10 on:
        - Relevance to the task
        - Quality of content
        - Clarity and style

        Provide scores and a brief justification.
      `)
    )
  );

  const scored = candidates.map((candidate, i) => {
    const { totalScore } = parseScores(evaluations[i]);
    return { candidate, score: totalScore };
  });

  scored.sort((a, b) => b.score - a.score);
  return scored[0].candidate;
}

async function exploreThenRefine(task: string) {
  const initialBest = await generateAndSelect(task, 5);

  const refined = await refineUntilGoodEnough(
    `Improve this response to the task:\n\n${task}\n\nResponse:\n${initialBest}`,
    2
  );

  return refined;
}

// Strict execution: plan as contract
const strictExecutionPrompt = `
  You are executing this plan exactly:

  Plan:
  1. Collect user requirements
  2. Propose three design options
  3. Compare options and recommend one

  You are on step 2 now. Do NOT change the plan.
`;

// Flexible execution: plan as guidance
const flexibleExecutionPrompt = `
  You are executing this plan:

  Plan:
  1. Collect user requirements
  2. Propose three design options
  3. Compare options and recommend one

  You may modify the plan if you uncover new information
  that makes a different sequence clearly better.
  When you do, explain why.
`;