Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Stebėjimas ir registravimas

Paskaita 13 iš 14 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Savo agento stebėjimas gamyboje
  2. Trys registravimo lygmenys
  3. Stebimi rodikliai
  4. Stebėjimo skydelis
  5. Automatiniai įspėjimai
  6. Svarbiausi punktai

Pamoka atnaujinta 2026 m. lapkričio 3 d. pagal „OpenAI“ Computer use gaires ir „Responses API“ dokumentaciją: registravimas dabar skaito veiksmus iš computer_call, o elementus – iš response.output (žinutės su jų phase, samprotavimo santraukos, kvietimai), vietoj „Anthropic“ API blokų tool_use; fiksuota „Claude Sonnet“ kainodara pakeista naudojamo modelio kainodara, o pasenusi datetime.utcnow() (nuo „Python“ 3.12) pakeista į datetime.now(timezone.utc). Šaltiniai: Computer use · Kainodara.

Savo agento stebėjimas gamyboje

Gamyboje veikiantis „Computer Use“ agentas yra juoda dėžė, jei nenustatysi tinkamo stebėjimo. Skirtingai nei standartinėje API, kur registruoji užklausas ir atsakymus, čia taip pat turi sekti vizualinius veiksmus, ekrano kopijas ir modelio sprendimus. Skirtumas konkretus: kai darbo eiga sutrinka 3 val. ryto, svarbus klausimas yra ne „kokia išimtis buvo išmesta“, o „ką agentas matė ir kodėl ten paspaudė?“. Žurnalas, kuris neatsako į šį klausimą, kitą rytą tau nepadės.

Trys registravimo lygmenys

Todėl instrumentavimas remiasi trimis papildomais sluoksniais: ką agentas darė, ką galvojo prieš tai darydamas ir ką matė priimdamas sprendimą. Kiekvienas rašo į skirtingą kanalą, nes nei apimtis, nei naudingumo trukmė nėra vienoda.

1 lygmuo: Veiksmai

Kiekvienas agento vykdytas veiksmas turi būti fiksuojamas. Toliau pateiktas formatas sistemingai prideda iteracijos numerį ir dabartinio žingsnio pavadinimą, leisdamas filtruoti kelių tūkstančių eilučių žurnalą iki vienos sekos, kuri nepavyko. Veiksmai ateina kaip objektai iš computer_call, su tais pačiais laukais kaip ir tavo tvarkyklėje (x, y, scroll_x, keys…). Atkreipk dėmesį į type veiksmo apdorojimą: registruojame įvesto teksto ilgį, bet niekada – jo turinį. Agentas, pildydamas prisijungimo formą, įveda slaptažodį, ir čia be išimties galioja ankstesnės pamokos taisyklė.

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())  # filtras iš 12 pamokos
logger.addHandler(handler)


def log_action(action, iteration: int, step: str = ""):
    """Registruoja veiksmą iš 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":
            # Niekada pats tekstas: tik jo ilgis
            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())

2 lygmuo: Modelio sprendimai

Registruok tai, ką modelis sako apie savo pasirinkimus, kad suprastum, kodėl jis pasirinko konkretų veiksmą. Paspaudimas netikėtose koordinatėse pats savaime nieko nereiškia; sujungtas su sakiniais, kurie buvo prieš tai – „pateikimo mygtukas, atrodo, uždengtas slapukų baneriu“ – tai tampa diagnoze. Tekstas sutrumpinamas iki dviejų šimtų simbolių; to daugiau nei pakanka suvokti ketinimą neišpūstant failo apimties. „Responses API“ atsakyme yra du teksto šaltiniai. Tarpinės žinutės, kurias modelis rašo prieš veikdamas, turi phase: "commentary", o galutinis atsakymas – phase: "final_answer". Ir jei naudojamas modelis palaiko samprotavimo santraukas, jas gausi paprašęs (reasoning={"summary": "auto"}): jos ateina elemento tipo reasoning pavidalu.

Žetonų suvartojimas registruojamas tuo pačiu tempu, ir tai nusipelno didelio dėmesio: net naudojant previous_response_id, visi ankstesnių grandinės atsakymų įvesties žetonai, įskaitant ekrano kopijas, vėl apmokestinami kaip įvestis. Todėl vieno ciklo kaina didėja ilgėjant sesijai.

def log_model_response(response, iteration: int):
    """Registruoja pastabas, santraukas ir kvietimus iš atsakymo (neįtraukiant vaizdų)."""
    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)

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

3 lygmuo: Ekrano kopijos

Išsaugok ekrano kopijas gedimų analizei po įvykio, bet saugok disko vietą: PNG kopija dažnai sveria kelis šimtus kilobaitų, o ilga darbo eiga jų sukuria šimtus. Toliau pateikta klasė tai išsprendžia paprastu rotavimu. Failo pavadinimas prasideda laiko žyma, suderinant abėcėlinę tvarką su chronologine; rūšiavimas _cleanup metode tada pakanka seniausioms kopijoms identifikuoti ir ištrinti, kol jų skaičius nukrenta žemiau šimto failų lubų. Laukas label leidžia anotuoti įdomius momentus, pavyzdžiui, error arba before_validation, ir juos greitai pastebėti aplanke.

from datetime import datetime, timezone
from pathlib import Path

class ScreenshotLogger:
    """Išsaugo ekrano kopijas su rotavimu."""

    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 = ""):
        """Išsaugo ekrano kopiją su aprašomuoju pavadinimu."""
        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):
        """Ištrina senas ekrano kopijas."""
        files = sorted(self.base_dir.glob("*.png"))
        while len(files) > self.max_files:
            files[0].unlink()
            files.pop(0)

Stebimi rodikliai

Sėkmės
rodiklis pagal darbo eigą
Vidutinė
trukmė vienam žingsniui
Kaina
žetonais vienam vykdymui
Klaidos
pagal tipą ir dažnumą

Šie keturi rodikliai yra vertingi tik lyginami su jais pačiais laikui bėgant: darbo eigos sėkmės rodikliui sumažėjus nuo devyniasdešimt penkių iki aštuoniasdešimt procentų, tai signalizuoja, kad sąsaja pasikeitė, gerokai anksčiau nei pirmasis vartotojas pasiskundžia. Todėl įdiek metrikų rinktuvą, prijungtą prie kiekvieno vykdymo. WorkflowMetrics duomenų klasė kaupia žetonus iteracija po iteracijos, seka klaidas su jų žingsniu ir laiko žyma, ir pateikia dvi apskaičiuojamas savybes: trukmę, kuri veikia net jei darbo eiga dar neužbaigta, ir kainos įvertį, pagrįstą naudojamo modelio kainodara, kurią imi iš „OpenAI“ kainodaros puslapio, o ne įrašai fiksuotai. Metodas summary sukuria kompaktišką žodyną, kurį archyvuosi kiekvieno vykdymo metu.

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

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

@dataclass
class WorkflowMetrics:
    """Renka darbo eigos metrikas."""
    workflow_id: str
    input_price_per_million: float  # naudojamo modelio kainodara
    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:
        # Įvertis: užuominų talpykla ir prieglobos aplinka neskaičiuojami
        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}",
        }

Stebėjimo skydelis

Stebėjimui realiuoju laiku siųsk metrikas į stebėjimo tarnybą, o ne leisk joms miegoti faile. Toliau pateikta funkcija siunčia laiko žyma pažymėtą santrauką į HTTP galinį tašką, imdamasi dviejų atsargumo priemonių, kurios yra tokios pat svarbios kaip ir pats siuntimas: maksimali penkių sekundžių delsos trukmė ir sugauta išimtis, kuri apsiriboja įspėjimu. Nepasiekiamas metrikų rinktuvas niekada neturi sustabdyti darbo eigos, kurią jis stebi – priešingas atvejis būtų kontraproduktyvios priežiūros apibrėžimas.

import requests  # pip install requests

def push_metrics(metrics: WorkflowMetrics, endpoint: str):
    """Siunčia metrikas į stebėjimo tarnybą."""
    payload = metrics.summary()
    payload["timestamp"] = now().isoformat()

    try:
        requests.post(
            endpoint,
            json=payload,  # requests pats nustato JSON antraštę
            timeout=5,
        )
    except requests.RequestException as e:
        logger.warning(f"Metrics push error: {e}")

Automatiniai įspėjimai

Skydelis, į kurį niekas nežiūri, yra tiesiog archyvas. Todėl sukonfigūruok įspėjimus pagal slenksčius, kad anomalija ateitų pas tave. Čia išlaikytos keturios sąlygos apima klasikinius nukrypimus: kaina didesnė nei du doleriai, trukmė viršija tris minutes, daugiau nei trisdešimt iteracijų arba daugiau nei dvi klaidos tame pačiame vykdyme. Šios vertės yra pradiniai taškai, o ne tiesos: sureguliuok jas pagal savo sėkmingų vykdymų matavimus, nustatydamas slenkstį gerokai aukščiau savo stebimos medianos. Įspėjimas, kuris suveikia kiekvieną dieną, antrosios savaitės pabaigoje bus ignoruojamas.

def check_alerts(metrics: WorkflowMetrics):
    """Tikrina slenksčius ir sukelia įspėjimus."""
    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}")
        # Siųsti pranešimą (el. paštu, „Slack“ ir kt.)

    return alerts

Įprask iškart po finalize iškviesti check_alerts, o tada push_metrics: taip gausi archyvuotą pėdsaką kiekvieno vykdymo metu, signalą, siunčiamą į skydelį, ir pranešimą tik tada, kai kažkas nusipelno tavo dėmesio.

Svarbiausi punktai

  • Registruok veiksmus, modelio žinutes bei santraukas ir fiksavimus trimis atskirais lygmenimis
  • Stebėk sėkmės rodiklį, trukmę, žetonų kainą ir klaidas; grandininė istorija kiekvieną ciklą vėl apmokestinama kaip įvestis
  • Įdiek ekrano kopijų rotavimą, kad išvengtum disko perpildymo
  • Nustatyk automatinius įspėjimus dėl kritinių slenksčių
  • Niekada neregistruok jautrių duomenų (slaptažodžių, žetonų, asmens duomenų)