8. משימות רקע

הבעיה

חלק מהפקודות לוקחות דקות: npm install, pytest, docker build. עם לולאה חוסמת, המודל יושב בלא פעולה ומחכה. אם המשתמש מבקש “התקן תלויות ובינתיים צור את קובץ התצורה,” הסוכן עושה אותם עוקבת, לא במקביל.

הפתרון

Main thread                Background thread
+-----------------+        +-----------------+
| agent loop      |        | subprocess runs |
| ...             |        | ...             |
| [LLM call] <---+------- | enqueue(result) |
|  ^drain queue   |        +-----------------+
+-----------------+

Timeline:
Agent --[spawn A]--[spawn B]--[other work]--[drain]--
             |          |                       ^
             v          v                       |
          [A runs]   [B runs]      (parallel)   |
             |          |                       |
             +----------+----- results injected-+

איך זה עובד

1. תור משותף אוסף תוצאות משימות רקע שהושלמו.

import threading
import subprocess
import queue

bg_queue: queue.Queue = queue.Queue()
bg_counter = {"n": 0}

def run_in_background(command: str, label: str = "") -> str:
    bg_counter["n"] += 1
    task_id = bg_counter["n"]
    label = label or f"bg-{task_id}"

    def worker():
        try:
            result = subprocess.run(
                command, shell=True, capture_output=True,
                text=True, timeout=300,
            )
            output = (result.stdout + result.stderr).strip()
            status = "done" if result.returncode == 0 else "failed"
        except subprocess.TimeoutExpired:
            output = "Timeout after 300s"
            status = "failed"
        bg_queue.put({
            "task_id": task_id,
            "label": label,
            "status": status,
            "output": output[:5000],
        })

    t = threading.Thread(target=worker, daemon=True)
    t.start()
    return f"Background task {task_id} ({label}) started. You'll be notified when done."

2. לפני כל קריאת LLM, רוקנו את התור והזריקו תוצאות שהושלמו.

def drain_bg_queue(messages: list) -> list:
    results = []
    while not bg_queue.empty():
        completed = bg_queue.get_nowait()
        results.append({
            "type": "text",
            "text": (
                f"<background_complete>\n"
                f"Task {completed['task_id']} ({completed['label']}): "
                f"{completed['status']}\n"
                f"{completed['output']}\n"
                f"</background_complete>"
            ),
        })
    if results:
        messages.append({"role": "user", "content": results})
    return messages

3. הלולאה הראשית קוראת ל-drain_bg_queue לפני כל קריאת LLM.

def agent_loop(messages: list):
    while True:
        messages = drain_bg_queue(messages)  # inject any completions
        response = client.messages.create(
            model=MODEL, system=SYSTEM,
            messages=messages, tools=TOOLS, max_tokens=8000,
        )
        messages.append({"role": "assistant", "content": response.content})

        if response.stop_reason != "tool_use":
            return

        results = []
        for block in response.content:
            if block.type == "tool_use":
                output = TOOL_HANDLERS[block.name](**block.input)
                results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": output,
                })
        messages.append({"role": "user", "content": results})

מה השתנה מ-מערכת משימות

מסקנה מרכזית

משימות רקע הן תבנית מקביליות לרתמת הסוכן. המודל לא צריך להבין threads — הוא פשוט קורא ל-run_in_background ומקבל התראה כשהמשימה מסתיימת. ריקון התור הוא המפתח: זו נקודת הזרקה יחידה שמזינה השלמות חזרה לשיחה בדיוק ברגע הנכון.