Files
checkbot/app/agent/executor.py
T
patrickandClaude Sonnet 5.5 c0975fe86b
test / pytest (3.11) (push) Waiting to run
test / pytest (3.13) (push) Waiting to run
feat: Agent-Tool search_sent_messages für das Ausgangslog
- sechstes, rein lesendes Tool: Bot-Nachrichten an Telegram/Matrix durchsuchen
- Argumente query, backend, since (max 30d), only_errors, limit (max 20), strikt validiert
- Treffertexte gekürzt und sanitized (untrusted), Aufrufe laufen über den Run-Recorder
- Agenten-Standardprompt, Tests, README und CLAUDE.md auf sechs Tools angepasst

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-19 12:57:45 +01:00

60 lines
2.8 KiB
Python

import asyncio
import inspect
from ..outbound import parse_since
from .constants import (MESSAGE_LIMIT_DEFAULT, MESSAGE_SINCE_DEFAULT, TOOL_DOWNTIMES, TOOL_HOST_SERVICES,
TOOL_PROBLEMS, TOOL_RESULT_MAX, TOOL_SEARCH_MESSAGES, TOOL_SERVICE_STATUS,
TOOL_STATE_HISTORY)
from .formatting import (format_downtimes, format_history, format_messages, format_services, format_status)
from .sanitize import sanitize
from .tools import ToolArgumentError, validate_arguments
from .types import CheckmkReader, OutboundSearch, StateLog
MESSAGES_UNAVAILABLE = "Fehler: Ausgangslog nicht verfügbar."
class ToolExecutor:
def __init__(self, reader: CheckmkReader, state_log: StateLog, outbound: OutboundSearch | None = None):
self._reader = reader
self._state_log = state_log
self._outbound = outbound
async def _dispatch(self, tool: str, args: dict[str, str]) -> str:
if tool == TOOL_SERVICE_STATUS:
return format_status(await self._reader.service_status(args["host"], args["service"]))
if tool == TOOL_HOST_SERVICES:
return format_services(await self._reader.host_services(args["host"]), with_host=False)
if tool == TOOL_STATE_HISTORY:
changes = self._state_log(args["host"], args["service"])
if inspect.isawaitable(changes):
changes = await changes
return format_history(changes)
if tool == TOOL_DOWNTIMES:
return format_downtimes(await self._reader.downtimes(args.get("host")))
if tool == TOOL_PROBLEMS:
return format_services(await self._reader.problems())
if tool == TOOL_SEARCH_MESSAGES:
return await self._search_messages(args)
raise ToolArgumentError("unbekanntes Tool")
async def _search_messages(self, args: dict) -> str:
if self._outbound is None:
return MESSAGES_UNAVAILABLE
since_ts = parse_since(args.get("since", MESSAGE_SINCE_DEFAULT))
entries = await asyncio.to_thread(
self._outbound.search, backend=args.get("backend"), query=args.get("query"),
only_errors=bool(args.get("only_errors", False)), since=since_ts,
limit=args.get("limit", MESSAGE_LIMIT_DEFAULT))
return format_messages(entries)
async def execute(self, tool: str, arguments: object) -> tuple[str, str | None]:
"""Liefert (Ergebnistext, Fehler); wirft nie."""
try:
args = validate_arguments(tool, arguments)
except ToolArgumentError as exc:
return f"Fehler: {exc}", str(exc)
try:
return sanitize(await self._dispatch(tool, args), TOOL_RESULT_MAX), None
except Exception as exc:
return "Fehler: Abfrage fehlgeschlagen.", type(exc).__name__