Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Nadzor i bilježenje

Lekcija 13 od 14 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. Promatranje tvog agenta u produkciji
  2. Tri razine bilježenja
  3. Metrike za praćenje
  4. Nadzorna ploča
  5. Automatska upozorenja
  6. Ključne točke

Lekcija ažurirana 3. studenog 2026. na temelju OpenAI-jevog vodiča Computer use i dokumentacije Responses API-ja: bilježenje sada čita radnje iz computer_call i elemente iz response.output (poruke s njihovim phase, sažecima razmišljanja, pozivima), umjesto blokova tool_use iz Anthropicovog API-ja; unaprijed definirane cijene za Claude Sonnet zamijenjene su cijenama modela koji se koristi, a zastarjeli datetime.utcnow() (od Pythona 3.12) zamijenjen je s datetime.now(timezone.utc). Izvori: Computer use · Cjenik.

Promatranje tvog agenta u produkciji

Agent za Computer Use u produkciji je crna kutija ako ne postaviš odgovarajući nadzor. Za razliku od standardnog API-ja gdje bilježiš zahtjeve i odgovore, ovdje moraš pratiti i vizualne radnje, snimke zaslona te odluke modela. Razlika je konkretna: kada tijek rada zakaže u 3 ujutro, pitanje koje je bitno nije „koji je izuzetak bačen“, već „što je agent vidio i zašto je kliknuo tamo?“. Zapisnik koji ne odgovara na to pitanje neće ti pomoći sljedećeg jutra.

Tri razine bilježenja

Instrumentacija se stoga gradi na tri komplementarna sloja: što je agent učinio, što je mislio prije nego što je to učinio i što je vidio kada je donosio odluku. Svaki piše u drugačiji kanal jer ni volumen ni korisni vijek trajanja nisu isti.

Razina 1: Radnje

Svaku radnju koju agent izvrši treba pratiti. Format u nastavku sustavno dodaje prefiks s brojem iteracije i nazivom trenutnog koraka, što ti omogućuje filtriranje zapisnika od nekoliko tisuća redaka na jedini slijed koji je pošlo po zlu. Radnje stižu kao objekti iz computer_call, s istim poljima kao u tvom handleru (x, y, scroll_x, keys…). Obrati pažnju na rukovanje radnjom type: bilježimo duljinu unesenog teksta, nikada njegov sadržaj. Agent koji ispunjava obrazac za prijavu upisuje lozinku, a pravilo iz prethodne lekcije ovdje vrijedi bez iznimke.

import logging

logger = logging.getLogger("computer_use")
logger.setLevel(logging.INFO)

handler = logging.FileHandler("agent.log")
handler.setFormatter(logging.Formatter("%(asctime)s | %(levelname)s | %(message)s"))
handler.addFilter(SensitiveFilter())  # filter from lesson 12
logger.addHandler(handler)


def log_action(action, iteration: int, step: str = ""):
    """Logs an action from a computer_call."""
    prefix = f"[iter={iteration}] [{step}]"
    match action.type:
        case "click" | "double_click" | "move":
            logger.info("%s %s at (%s, %s)", prefix, action.type.upper(), action.x, action.y)
        case "type":
            # Never the text itself: only its length
            logger.info("%s TYPE (%d chars)", prefix, len(action.text))
        case "scroll":
            logger.info("%s SCROLL dx=%s dy=%s", prefix, action.scroll_x, action.scroll_y)
        case "keypress":
            logger.info("%s KEYPRESS %s", prefix, "+".join(action.keys))
        case "drag":
            logger.info("%s DRAG (%d points)", prefix, len(action.path))
        case _:
            logger.info("%s %s", prefix, action.type.upper())

Razina 2: Odluke modela

Bilježi što model kaže o svojim izborima kako bi razumio zašto je odabrao specifičnu radnju. Klik na neočekivanim koordinatama sam po sebi ne znači ništa; u paru s rečenicom koja mu je prethodila – „gumb za slanje čini se skrivenim iza bannera za kolačiće“ – postaje dijagnoza. Tekst se skraćuje na dvjesto znakova, što je više nego dovoljno da se shvati namjera bez eksplodiranja volumena datoteke. U odgovoru Responses API-ja postoje dva izvora teksta. Međuporuke koje model piše prije djelovanja nose phase: "commentary", dok konačni odgovor nosi phase: "final_answer". A ako model koji koristiš podržava sažetke razmišljanja, dobivaš ih njihovim zahtijevanjem (reasoning={"summary": "auto"}): oni stižu u elementima tipa reasoning.

Potrošnja tokena bilježi se istim ritmom i zaslužuje pomnu pozornost: čak i uz previous_response_id, svi ulazni tokeni iz prethodnih odgovora u lancu ponovno se naplaćuju kao ulaz, uključujući snimke zaslona. Trošak okrugla stoga raste kako sesija traje.

def log_model_response(response, iteration: int):
    """Logs notes, summaries, and calls from a response (excluding images)."""
    for item in response.output:
        if item.type == "reasoning":
            for summary in item.summary:
                logger.info("[iter=%d] REASONING: %s", iteration, summary.text[:200])
        elif item.type == "message":
            text = "".join(c.text for c in item.content if c.type == "output_text")
            logger.info("[iter=%d] MESSAGE (%s): %s", iteration, item.phase or "-", text[:200])
        elif item.type == "computer_call":
            actions = ", ".join(a.type for a in item.actions or [])
            logger.info("[iter=%d] COMPUTER_CALL %s: %s", iteration, item.call_id, actions)
        elif item.type == "function_call":
            logger.info("[iter=%d] FUNCTION_CALL %s", iteration, item.name)

    # Tokens consumed
    logger.info(
        "[iter=%d] TOKENS: in=%d out=%d",
        iteration, response.usage.input_tokens, response.usage.output_tokens,
    )

Razina 3: Snimke zaslona

Spremi snimke zaslona za naknadnu analizu grešaka, ali pazi na prostor na disku: PNG snimka često teži nekoliko stotina kilobajta, a dugi tijek rada proizvodi njih stotine. Donja klasa to rješava jednostavnom rotacijom. Ime datoteke počinje vremenskom oznakom, usklađujući abecedni redoslijed s kronološkim; sortiranje u _cleanup tada je dovoljno da se identificiraju najstarije snimke i obrišu dok se ne spusti ispod stropa od sto datoteka. Polje label omogućuje ti annotiranje zanimljivih trenutaka, na primjer error ili before_validation, i njihovo brzo uočavanje u mapi.

from datetime import datetime, timezone
from pathlib import Path

class ScreenshotLogger:
    """Saves screenshots with rotation."""

    def __init__(self, base_dir: str = "logs/screenshots", max_files: int = 100):
        self.base_dir = Path(base_dir)
        self.base_dir.mkdir(parents=True, exist_ok=True)
        self.max_files = max_files
        self.counter = 0

    def save(self, screenshot_bytes: bytes, iteration: int, label: str = ""):
        """Saves a screenshot with a descriptive name."""
        ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
        filename = f"{ts}_iter{iteration:03d}_{label}.png"
        filepath = self.base_dir / filename

        with open(filepath, "wb") as f:
            f.write(screenshot_bytes)

        self.counter += 1
        self._cleanup()

        return filepath

    def _cleanup(self):
        """Deletes old screenshots."""
        files = sorted(self.base_dir.glob("*.png"))
        while len(files) > self.max_files:
            files[0].unlink()
            files.pop(0)

Metrike za praćenje

Uspješnost
po tijeku rada
Prosječno
trajanje po koraku
Trošak
u tokenima po izvršenju
Greške
po vrsti i učestalosti

Ova četiri pokazatelja vrijede samo kada se uspoređuju sama sa sobom kroz vrijeme: tijek rada koji padne s devedeset pet na osamdeset posto uspješnosti govori ti da se sučelje pomaknulo, daleko prije nego što se prvi korisnik požali. Stoga implementiraj kolektor metrika povezan sa svakim izvršenjem. Podatkovna klasa WorkflowMetrics akumulira tokene iteraciju za iteracijom, prati greške s njihovim korakom i vremenskom oznakom te izlaže dva izračunata svojstva: trajanje, koje funkcionira čak i ako tijek rada još nije završen, i procjenu troška na temelju cjenika modela koji se koristi, koji uzimaš sa OpenAI stranice s cijenama umjesto da ga unaprijed definiraš. Metoda summary proizvodi kompaktni rječnik koji ćeš arhivirati pri svakom izvršenju.

from dataclasses import dataclass, field
from datetime import datetime, timezone

def now() -> datetime:
    return datetime.now(timezone.utc)

@dataclass
class WorkflowMetrics:
    """Collects metrics for a workflow."""
    workflow_id: str
    input_price_per_million: float  # pricing for the model in use
    output_price_per_million: float
    start_time: datetime = field(default_factory=now)
    end_time: datetime | None = None
    iterations: int = 0
    total_input_tokens: int = 0
    total_output_tokens: int = 0
    errors: list = field(default_factory=list)
    steps_completed: int = 0
    steps_total: int = 0

    def record_iteration(self, response):
        self.iterations += 1
        self.total_input_tokens += response.usage.input_tokens
        self.total_output_tokens += response.usage.output_tokens

    def record_error(self, error: str, step: str):
        self.errors.append({
            "step": step,
            "error": error,
            "timestamp": now().isoformat(),
        })

    def finalize(self):
        self.end_time = now()

    @property
    def duration_seconds(self) -> float:
        end = self.end_time or now()
        return (end - self.start_time).total_seconds()

    @property
    def estimated_cost_usd(self) -> float:
        # Estimate: prompt caching and a hosted environment are not counted
        input_cost = self.total_input_tokens / 1_000_000 * self.input_price_per_million
        output_cost = self.total_output_tokens / 1_000_000 * self.output_price_per_million
        return input_cost + output_cost

    def summary(self) -> dict:
        return {
            "workflow_id": self.workflow_id,
            "duration_s": round(self.duration_seconds, 1),
            "iterations": self.iterations,
            "tokens": self.total_input_tokens + self.total_output_tokens,
            "cost_usd": round(self.estimated_cost_usd, 4),
            "success": len(self.errors) == 0,
            "errors": len(self.errors),
            "steps": f"{self.steps_completed}/{self.steps_total}",
        }

Nadzorna ploča

Za nadzor u stvarnom vremenu šalji metrike usluzi za nadzor umjesto da im dopustiš da spavaju u datoteci. Donja funkcija objavljuje sažetak s vremenskom oznakom na HTTP krajnju točku, s dvije mjere opreza koje su jednako važne kao i samo slanje: maksimalno kašnjenje od pet sekundi i uhvaćeni izuzetak koji se zadovoljava upozorenjem. Nedostupan kolektor metrika nikada ne smije srušiti tijek rada koji promatra – suprotno bi bila definicija kontraproduktivnog nadzora.

import requests  # pip install requests

def push_metrics(metrics: WorkflowMetrics, endpoint: str):
    """Sends metrics to a monitoring service."""
    payload = metrics.summary()
    payload["timestamp"] = now().isoformat()

    try:
        requests.post(
            endpoint,
            json=payload,  # requests sets the JSON header itself
            timeout=5,
        )
    except requests.RequestException as e:
        logger.warning(f"Metrics push error: {e}")

Automatska upozorenja

Nadzorna ploča koju nitko ne gleda samo je arhiva. Stoga konfiguriraj upozorenja na temelju pragova kako bi ti anomalija sama došla. Četiri ovdje zadržana uvjeta pokrivaju klasična odstupanja: trošak veći od dva dolara, trajanje koje prelazi tri minute, više od trideset iteracija ili više od dvije greške u istom izvršenju. Ove vrijednosti su polazišta, a ne istine: kalibriraj ih na mjerenjima iz vlastitih uspješnih izvršenja, postavljajući prag daleko iznad tvoje uočene medijane. Upozorenje koje se okida svaki dan bit će ignorirano drugog tjedna.

def check_alerts(metrics: WorkflowMetrics):
    """Checks thresholds and triggers alerts."""
    alerts = []

    if metrics.estimated_cost_usd > 2.0:
        alerts.append(f"High cost: ${metrics.estimated_cost_usd:.2f}")

    if metrics.duration_seconds > 180:
        alerts.append(f"Excessive duration: {metrics.duration_seconds:.0f}s")

    if metrics.iterations > 30:
        alerts.append(f"Too many iterations: {metrics.iterations}")

    if len(metrics.errors) > 2:
        alerts.append(f"Multiple errors: {len(metrics.errors)}")

    for alert in alerts:
        logger.warning(f"ALERT: {alert}")
        # Send notification (email, Slack, etc.)

    return alerts

Uzmi si u naviku zvati check_alerts odmah nakon finalize, a zatim push_metrics: dobivaš arhivirani trag pri svakom izvršenju, signal poslan nadzornoj ploči i obavijest samo kada nešto zaslužuje tvoju pozornost.

Ključne točke

  • Bilježi radnje, poruke i sažetke modela te snimke na tri odvojene razine
  • Prati stopu uspješnosti, trajanje, trošak tokena i greške; lančana povijest se naplaćuje kao ulaz svakog okrugla
  • Implementiraj rotaciju snimki zaslona kako bi izbjegao zasićenje diska
  • Postavi automatska upozorenja na kritične pragove
  • Nikada ne bilježi osjetljive podatke (lozinke, tokene, osobne podatke)