- 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>
60 lines
2.8 KiB
Python
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__
|