monkeybot 2.1.1__py3-none-any.whl

monkeybot/scheduler/engine.py

@@ -0,0 +1,333 @@
+"""Poll-and-fire engine for prompt-first scheduled agent loops."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+import os
+import time
+import uuid
+from dataclasses import dataclass
+from typing import Protocol
+
+from monkeybot.core.persistence.backends import ScheduledLoopStore
+from monkeybot.core.persistence.scheduled_loops import ScheduledLoopRow, format_tick_prompt
+from monkeybot.core.types.content_blocks import ContentBlock, Text
+from monkeybot.scheduler.tick_result import TickInvokeResult, TickInvokeStatus
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_HEARTBEAT_INTERVAL_S = 30.0
+
+
+class SessionBusyChecker(Protocol):
+    def is_busy(self, session_id: str) -> bool: ...
+
+
+class AsyncSessionBusyChecker(Protocol):
+    async def is_busy_async(self, session_id: str) -> bool: ...
+
+
+class SessionEnsurer(Protocol):
+    async def ensure_session(self, session_id: str) -> None: ...
+
+
+class TickInvoker(Protocol):
+    async def invoke_tick(
+        self,
+        session_id: str,
+        request_id: str,
+        user_content: list[ContentBlock],
+    ) -> TickInvokeResult:
+        """Run one scheduled tick."""
+
+
+def _env_float(name: str, default: float) -> float:
+    raw = os.environ.get(name, "").strip()
+    if not raw:
+        return default
+    try:
+        return float(raw)
+    except ValueError:
+        return default
+
+
+def _env_int(name: str, default: int) -> int:
+    raw = os.environ.get(name, "").strip()
+    if not raw:
+        return default
+    try:
+        return int(raw)
+    except ValueError:
+        return default
+
+
+@dataclass(frozen=True)
+class SchedulerSettings:
+    poll_interval_s: float
+    stale_claim_ms: int
+    max_concurrency: int
+    claim_heartbeat_interval_s: float
+
+
+def scheduler_settings() -> SchedulerSettings:
+    stale_claim_ms = _env_int("MONKEYBOT_SCHEDULER_STALE_CLAIM_MS", 600_000)
+    heartbeat_raw = os.environ.get("MONKEYBOT_SCHEDULER_CLAIM_HEARTBEAT_S", "").strip()
+    if heartbeat_raw:
+        heartbeat_s = _env_float("MONKEYBOT_SCHEDULER_CLAIM_HEARTBEAT_S", _DEFAULT_HEARTBEAT_INTERVAL_S)
+    else:
+        heartbeat_s = min(_DEFAULT_HEARTBEAT_INTERVAL_S, max(5.0, stale_claim_ms / 4000.0))
+    return SchedulerSettings(
+        poll_interval_s=_env_float("MONKEYBOT_SCHEDULER_POLL_INTERVAL_S", 5.0),
+        stale_claim_ms=stale_claim_ms,
+        max_concurrency=max(1, _env_int("MONKEYBOT_SCHEDULER_CONCURRENCY", 1)),
+        claim_heartbeat_interval_s=heartbeat_s,
+    )
+
+
+def scheduler_enabled_from_env() -> bool:
+    raw = os.environ.get("MONKEYBOT_SCHEDULER_ENABLED", "").strip().lower()
+    return raw in {"1", "true", "yes", "on"}
+
+
+def resolve_scheduler_worker_id() -> str:
+    explicit = os.environ.get("MONKEYBOT_SCHEDULER_WORKER_ID", "").strip()
+    if explicit:
+        return explicit
+    return f"scheduler-{uuid.uuid4().hex[:12]}"
+
+
+async def _claim_heartbeat(
+    *,
+    store: ScheduledLoopStore,
+    loop_id: str,
+    worker_id: str,
+    interval_s: float,
+    stop: asyncio.Event,
+) -> None:
+    while not stop.is_set():
+        try:
+            await asyncio.wait_for(stop.wait(), timeout=interval_s)
+            return
+        except TimeoutError:
+            renewed = await store.renew_tick_claim(loop_id, worker_id)
+            if not renewed:
+                return
+
+
+async def run_scheduler_loop(
+    *,
+    store: ScheduledLoopStore,
+    invoker: TickInvoker,
+    session_busy: SessionBusyChecker,
+    ensure_session: SessionEnsurer,
+    worker_id: str,
+    poll_interval_s: float = 5.0,
+    stale_claim_ms: int = 600_000,
+    max_concurrency: int = 1,
+    claim_heartbeat_interval_s: float = _DEFAULT_HEARTBEAT_INTERVAL_S,
+    shutdown: asyncio.Event | None = None,
+) -> None:
+    """Poll due loops and invoke agent ticks until ``shutdown`` is set."""
+    semaphore = asyncio.Semaphore(max(1, max_concurrency))
+    tick_tasks: set[asyncio.Task[None]] = set()
+
+    def _prune_done() -> None:
+        tick_tasks.difference_update({task for task in tick_tasks if task.done()})
+
+    while shutdown is None or not shutdown.is_set():
+        try:
+            released = await store.release_stale_claims(stale_claim_ms)
+            if released:
+                logger.warning("scheduler released %d stale tick claims", released)
+            now_ms = int(time.time() * 1000)
+            due = await store.list_due(now_ms)
+            claimed_rows: list[ScheduledLoopRow] = []
+            for candidate in due:
+                if shutdown is not None and shutdown.is_set():
+                    break
+                claimed = await store.claim_tick(candidate.loop_id, worker_id)
+                if claimed is not None:
+                    claimed_rows.append(claimed)
+
+            async def _run_claimed(row: ScheduledLoopRow) -> None:
+                async with semaphore:
+                    await _execute_claimed_tick(
+                        store=store,
+                        invoker=invoker,
+                        session_busy=session_busy,
+                        ensure_session=ensure_session,
+                        row=row,
+                        worker_id=worker_id,
+                        claim_heartbeat_interval_s=claim_heartbeat_interval_s,
+                    )
+
+            for row in claimed_rows:
+                if shutdown is not None and shutdown.is_set():
+                    break
+                task = asyncio.create_task(
+                    _run_claimed(row),
+                    name=f"scheduler-tick-{row.loop_id}",
+                )
+                tick_tasks.add(task)
+                task.add_done_callback(tick_tasks.discard)
+            _prune_done()
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.exception("scheduler poll loop error worker_id=%s", worker_id)
+        if shutdown is not None and shutdown.is_set():
+            break
+        await asyncio.sleep(poll_interval_s)
+
+    if tick_tasks:
+        await asyncio.gather(*tick_tasks, return_exceptions=True)
+
+
+async def _session_is_busy(session_busy: SessionBusyChecker, session_id: str) -> bool:
+    async_check = getattr(session_busy, "is_busy_async", None)
+    if async_check is not None:
+        return bool(await async_check(session_id))
+    return session_busy.is_busy(session_id)
+
+
+async def _execute_claimed_tick(
+    *,
+    store: ScheduledLoopStore,
+    invoker: TickInvoker,
+    session_busy: SessionBusyChecker,
+    ensure_session: SessionEnsurer,
+    row: ScheduledLoopRow,
+    worker_id: str,
+    claim_heartbeat_interval_s: float,
+) -> None:
+    if row.skip_if_busy and await _session_is_busy(session_busy, row.session_id):
+        await store.defer_tick(
+            row.loop_id,
+            worker_id=worker_id,
+            reason="session busy; deferred",
+        )
+        logger.info(
+            "scheduler deferred tick loop_id=%s session_id=%s (busy)",
+            row.loop_id,
+            row.session_id,
+        )
+        return
+
+    heartbeat_stop = asyncio.Event()
+    heartbeat_task = asyncio.create_task(
+        _claim_heartbeat(
+            store=store,
+            loop_id=row.loop_id,
+            worker_id=worker_id,
+            interval_s=claim_heartbeat_interval_s,
+            stop=heartbeat_stop,
+        ),
+        name=f"scheduler-heartbeat-{row.loop_id}",
+    )
+    try:
+        await ensure_session.ensure_session(row.session_id)
+        request_id = f"loop-{row.loop_id}-{row.tick_index + 1}-{uuid.uuid4().hex[:8]}"
+        tick_prompt = format_tick_prompt(row)
+        result = await invoker.invoke_tick(
+            row.session_id,
+            request_id,
+            [Text(text=tick_prompt)],
+        )
+        if result.status is TickInvokeStatus.SESSION_BUSY:
+            await store.defer_tick(
+                row.loop_id,
+                worker_id=worker_id,
+                reason="session busy; deferred",
+            )
+            logger.info(
+                "scheduler deferred tick loop_id=%s session_id=%s (remote busy)",
+                row.loop_id,
+                row.session_id,
+            )
+            return
+
+        error = result.error if result.status is TickInvokeStatus.ERROR else None
+        await store.complete_tick(row.loop_id, worker_id=worker_id, error=error)
+        if error:
+            logger.warning(
+                "scheduler tick failed loop_id=%s session_id=%s error=%s",
+                row.loop_id,
+                row.session_id,
+                error,
+            )
+        else:
+            logger.info(
+                "scheduler tick ok loop_id=%s session_id=%s tick=%d",
+                row.loop_id,
+                row.session_id,
+                row.tick_index + 1,
+            )
+    except Exception as exc:
+        logger.exception("scheduler tick exception loop_id=%s", row.loop_id)
+        await store.complete_tick(row.loop_id, worker_id=worker_id, error=str(exc))
+    finally:
+        heartbeat_stop.set()
+        heartbeat_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await heartbeat_task
+
+
+@dataclass
+class SchedulerHandle:
+    task: asyncio.Task[None]
+    shutdown: asyncio.Event
+
+
+def start_scheduler_background(
+    *,
+    store: ScheduledLoopStore,
+    invoker: TickInvoker,
+    session_busy: SessionBusyChecker,
+    ensure_session: SessionEnsurer,
+    worker_id: str | None = None,
+    poll_interval_s: float | None = None,
+    stale_claim_ms: int | None = None,
+    max_concurrency: int | None = None,
+    claim_heartbeat_interval_s: float | None = None,
+) -> SchedulerHandle:
+    settings = scheduler_settings()
+    shutdown = asyncio.Event()
+    wid = worker_id or resolve_scheduler_worker_id()
+    task = asyncio.create_task(
+        run_scheduler_loop(
+            store=store,
+            invoker=invoker,
+            session_busy=session_busy,
+            ensure_session=ensure_session,
+            worker_id=wid,
+            poll_interval_s=(
+                poll_interval_s if poll_interval_s is not None else settings.poll_interval_s
+            ),
+            stale_claim_ms=stale_claim_ms if stale_claim_ms is not None else settings.stale_claim_ms,
+            max_concurrency=(
+                max_concurrency if max_concurrency is not None else settings.max_concurrency
+            ),
+            claim_heartbeat_interval_s=(
+                claim_heartbeat_interval_s
+                if claim_heartbeat_interval_s is not None
+                else settings.claim_heartbeat_interval_s
+            ),
+            shutdown=shutdown,
+        ),
+        name=f"monkeybot-scheduler-{wid}",
+    )
+    return SchedulerHandle(task=task, shutdown=shutdown)
+
+
+async def shutdown_scheduler(handle: SchedulerHandle, *, drain_timeout_s: float = 30.0) -> None:
+    handle.shutdown.set()
+    try:
+        await asyncio.wait_for(handle.task, timeout=drain_timeout_s)
+    except TimeoutError:
+        handle.task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await handle.task
+    except asyncio.CancelledError:
+        raise

monkeybot/scheduler/http_invoker.py

@@ -0,0 +1,61 @@
+"""HTTP tick invoker for standalone scheduler workers."""
+
+from __future__ import annotations
+
+import httpx
+
+from monkeybot.core.types.content_blocks import ContentBlock, Text
+from monkeybot.scheduler.tick_result import TickInvokeResult
+
+
+class HttpTickInvoker:
+    """Call the gateway ``/scheduler/invoke-tick`` endpoint synchronously."""
+
+    def __init__(self, base_url: str, *, timeout_s: float = 3600.0) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._timeout_s = timeout_s
+        self._sessions_ready: set[str] = set()
+
+    async def _ensure_session(self, client: httpx.AsyncClient, session_id: str) -> TickInvokeResult | None:
+        if session_id in self._sessions_ready:
+            return None
+        session_resp = await client.post(
+            f"{self._base_url}/sessions",
+            json={"session_id": session_id},
+        )
+        if session_resp.status_code in (201, 409):
+            self._sessions_ready.add(session_id)
+            return None
+        return TickInvokeResult.fail(
+            f"create session failed: {session_resp.status_code} {session_resp.text}"
+        )
+
+    async def invoke_tick(
+        self,
+        session_id: str,
+        request_id: str,
+        user_content: list[ContentBlock],
+    ) -> TickInvokeResult:
+        message = "\n".join(
+            block.text for block in user_content if isinstance(block, Text)
+        )
+        payload = {
+            "session_id": session_id,
+            "request_id": request_id,
+            "message": message,
+        }
+        async with httpx.AsyncClient(timeout=self._timeout_s) as client:
+            try:
+                ensure_err = await self._ensure_session(client, session_id)
+                if ensure_err is not None:
+                    return ensure_err
+                resp = await client.post(f"{self._base_url}/scheduler/invoke-tick", json=payload)
+            except httpx.HTTPError as exc:
+                return TickInvokeResult.fail(str(exc))
+        if resp.status_code == 409:
+            return TickInvokeResult.session_busy()
+        if resp.status_code >= 400:
+            return TickInvokeResult.fail(
+                f"invoke-tick failed: {resp.status_code} {resp.text}"
+            )
+        return TickInvokeResult.ok()

monkeybot/scheduler/interval.py

@@ -0,0 +1,77 @@
+"""Parse human interval strings for scheduled loops."""
+
+from __future__ import annotations
+
+import os
+import re
+
+_INTERVAL_RE = re.compile(
+    r"^\s*(?P<num>\d+(?:\.\d+)?)\s*(?P<unit>s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours)?\s*$",
+    re.IGNORECASE,
+)
+
+_UNIT_TO_MS: dict[str, int] = {
+    "s": 1000,
+    "sec": 1000,
+    "secs": 1000,
+    "second": 1000,
+    "seconds": 1000,
+    "m": 60_000,
+    "min": 60_000,
+    "mins": 60_000,
+    "minute": 60_000,
+    "minutes": 60_000,
+    "h": 3_600_000,
+    "hr": 3_600_000,
+    "hrs": 3_600_000,
+    "hour": 3_600_000,
+    "hours": 3_600_000,
+}
+
+
+_MIN_INTERVAL_MS = 5_000
+
+
+def min_interval_ms() -> int:
+    raw = os.environ.get("MONKEYBOT_SCHEDULER_MIN_INTERVAL_MS", "").strip()
+    if not raw:
+        return _MIN_INTERVAL_MS
+    try:
+        return max(1, int(raw))
+    except ValueError:
+        return _MIN_INTERVAL_MS
+
+
+def parse_interval_ms(value: str | int | float) -> int:
+    """Parse ``20s``, ``5m``, ``1h``, or raw seconds into milliseconds."""
+    if isinstance(value, (int, float)):
+        seconds = float(value)
+        if seconds <= 0:
+            raise ValueError("interval must be positive")
+        ms = max(1, int(seconds * 1000))
+    else:
+        raw = str(value).strip()
+        if not raw:
+            raise ValueError("interval is required")
+        match = _INTERVAL_RE.match(raw)
+        if not match:
+            raise ValueError(f"invalid interval: {value!r}")
+        num = float(match.group("num"))
+        if num <= 0:
+            raise ValueError("interval must be positive")
+        unit = (match.group("unit") or "s").lower()
+        ms = int(num * _UNIT_TO_MS[unit])
+        ms = max(1, ms)
+    floor = min_interval_ms()
+    if ms < floor:
+        raise ValueError(f"interval must be at least {floor}ms")
+    return ms
+
+
+def parse_optional_duration_ms(value: str | int | float | None) -> int | None:
+    """Parse optional max-runtime style durations."""
+    if value is None:
+        return None
+    if isinstance(value, str) and not value.strip():
+        return None
+    return parse_interval_ms(value)

monkeybot/scheduler/tick_result.py

@@ -0,0 +1,34 @@
+"""Typed outcomes from a scheduled-loop tick invocation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+class TickInvokeStatus(StrEnum):
+    """Result of one scheduler tick invocation."""
+
+    OK = "ok"
+    SESSION_BUSY = "session_busy"
+    ERROR = "error"
+
+
+@dataclass(frozen=True)
+class TickInvokeResult:
+    """Outcome passed from :class:`TickInvoker` to the scheduler engine."""
+
+    status: TickInvokeStatus
+    error: str | None = None
+
+    @classmethod
+    def ok(cls) -> TickInvokeResult:
+        return cls(status=TickInvokeStatus.OK)
+
+    @classmethod
+    def session_busy(cls) -> TickInvokeResult:
+        return cls(status=TickInvokeStatus.SESSION_BUSY)
+
+    @classmethod
+    def fail(cls, message: str) -> TickInvokeResult:
+        return cls(status=TickInvokeStatus.ERROR, error=message)

monkeybot/scheduler/worker.py

@@ -0,0 +1,87 @@
+"""Standalone scheduler worker (HTTP client to a running gateway)."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+
+from monkeybot.core.config.settings import auto_schema_enabled_from_config
+from monkeybot.core.persistence.backends import StorageBackend, create_storage_backend
+from monkeybot.gateway.bootstrap import ensure_gateway_runtime_env
+from monkeybot.scheduler.engine import (
+    resolve_scheduler_worker_id,
+    run_scheduler_loop,
+    scheduler_settings,
+)
+from monkeybot.scheduler.http_invoker import HttpTickInvoker
+
+logger = logging.getLogger(__name__)
+
+
+class _NoopSessionBusyChecker:
+    """Remote busy detection is handled by :class:`HttpTickInvoker` (HTTP 409)."""
+
+    def is_busy(self, session_id: str) -> bool:
+        del session_id
+        return False
+
+
+class _NoopSessionEnsurer:
+    """Session creation is handled by :class:`HttpTickInvoker` before each tick."""
+
+    async def ensure_session(self, session_id: str) -> None:
+        del session_id
+
+
+def _gateway_base_url() -> str:
+    port = os.environ.get("PORT", os.environ.get("GATEWAY_PORT", "8000"))
+    host = os.environ.get("MONKEYBOT_GATEWAY_HOST", "127.0.0.1")
+    explicit = os.environ.get("MONKEYBOT_GATEWAY_URL", "").strip()
+    if explicit:
+        return explicit.rstrip("/")
+    return f"http://{host}:{port}"
+
+
+async def _run() -> None:
+    ensure_gateway_runtime_env()
+    db_url = os.environ.get("DB_URL", "sqlite:///data/monkeybot.db")
+    backend: StorageBackend = create_storage_backend(db_url)
+    await backend.open(run_schema=auto_schema_enabled_from_config())
+    settings = scheduler_settings()
+    worker_id = resolve_scheduler_worker_id()
+    base_url = _gateway_base_url()
+    invoker = HttpTickInvoker(base_url)
+    logger.info(
+        "scheduler worker starting worker_id=%s gateway=%s poll_interval_s=%s concurrency=%s",
+        worker_id,
+        base_url,
+        settings.poll_interval_s,
+        settings.max_concurrency,
+    )
+    try:
+        await run_scheduler_loop(
+            store=backend.scheduled_loops(),
+            invoker=invoker,
+            session_busy=_NoopSessionBusyChecker(),
+            ensure_session=_NoopSessionEnsurer(),
+            worker_id=worker_id,
+            poll_interval_s=settings.poll_interval_s,
+            stale_claim_ms=settings.stale_claim_ms,
+            max_concurrency=settings.max_concurrency,
+            claim_heartbeat_interval_s=settings.claim_heartbeat_interval_s,
+        )
+    finally:
+        await backend.close()
+
+
+def main() -> None:
+    logging.basicConfig(level=os.environ.get("LOG_LEVEL", "INFO"))
+    try:
+        asyncio.run(_run())
+    except KeyboardInterrupt:
+        raise SystemExit(130) from None
+
+
+if __name__ == "__main__":
+    main()

monkeybot/subagents/__init__.py

@@ -0,0 +1 @@
+"""Top-level subagent worker package."""

monkeybot/subagents/worker/__init__.py

@@ -0,0 +1 @@
+"""Worker entry package."""

monkeybot/subagents/worker/__main__.py

@@ -0,0 +1,22 @@
+"""Standalone worker process for queued subagent runs."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+
+from monkeybot.core.logging_utils import normalize_log_level
+from monkeybot.core.subagents.worker_pool import run_worker_main
+
+
+def main() -> None:
+    logging.basicConfig(level=normalize_log_level(os.environ.get("LOG_LEVEL"), default="INFO"))
+    try:
+        asyncio.run(run_worker_main())
+    except KeyboardInterrupt:
+        raise SystemExit(0) from None
+
+
+if __name__ == "__main__":
+    main()