Pattern agentici: pianificare, eseguire, verificare

Perché pianificare prima?

Passaggio 1: pianificare

PLAN_PROMPT = '''
You are a senior engineer. Given this task, produce a JSON plan:
{steps: [{description, files_to_touch: [str], test_commands: [str]}], risks: [str]}

Task: {user_task}
'''

Plan Schema

from pydantic import BaseModel

class Step(BaseModel):
    description: str
    files_to_touch: list[str]
    test_commands: list[str]

class Plan(BaseModel):
    steps: list[Step]
    risks: list[str]

Passaggio 2: eseguire

for step in plan.steps:
    context = {f: read_file(f) for f in step.files_to_touch}
    diff = llm.invoke(f'Implement: {step.description}\nFiles:\n{context}').content
    apply_diff(diff)

Passaggio 3: verificare

for cmd in step.test_commands:
    result = sandbox.run(cmd)
    if result.exit_code != 0:
        # Verification failed; iterate
        loop_until_verified(step, result.stderr)

Step 4: Iterate Until Pass

MAX_ITERS = 5
for iter in range(MAX_ITERS):
    result = sandbox.run(test_cmd)
    if result.exit_code == 0:
        break
    fix = llm.invoke(f'Tests failed:\n{result.stderr}\nFix the code.').content
    apply_diff(fix)

Mostrare i diff, non i file completi

diff = '''
--- a/main.py
+++ b/main.py
@@ -10,3 +10,4 @@
  def add(a, b):
      return a + b
+
+def sub(a, b): return a - b
'''
import patch
patch.fromstring(diff).apply()

La qualità del piano è importante

R pianificare quando si è bloccati

if iter == MAX_ITERS - 1:
    new_plan = llm.invoke(f'Original plan failed. Errors: {errors}. Make a new plan.').content

Compromesso della pianificazione su orizzonti lunghi

Piano + revisore

Mostrare il piano all'utente

approved_plan = await ask_user_to_approve_or_edit(plan)
execute(approved_plan)

Pianificare-Eseguire-Verificare

Riepilogo