Stebėjimas ir registravimas
Šiame puslapyje
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 pasenusidatetime.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
Š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ų)