codex-autorunner 0.1.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

codex_autorunner/integrations/agents/codex_backend.py

@@ -0,0 +1,307 @@
+import asyncio
+import logging
+from pathlib import Path
+from typing import Any, AsyncGenerator, Dict, Optional, Union
+
+from ...core.circuit_breaker import CircuitBreaker
+from ...integrations.app_server.client import CodexAppServerClient
+from .agent_backend import AgentBackend, AgentEvent, now_iso
+from .run_event import (
+    ApprovalRequested,
+    Completed,
+    Failed,
+    OutputDelta,
+    RunEvent,
+    Started,
+    ToolCall,
+)
+
+_logger = logging.getLogger(__name__)
+
+ApprovalDecision = Union[str, Dict[str, Any]]
+
+
+class CodexAppServerBackend(AgentBackend):
+    def __init__(
+        self,
+        command: list[str],
+        *,
+        cwd: Optional[Path] = None,
+        env: Optional[Dict[str, str]] = None,
+        approval_policy: Optional[str] = None,
+        sandbox_policy: Optional[str] = None,
+    ):
+        self._command = command
+        self._cwd = cwd
+        self._env = env
+        self._approval_policy = approval_policy
+        self._sandbox_policy = sandbox_policy
+
+        self._client: Optional[CodexAppServerClient] = None
+        self._session_id: Optional[str] = None
+        self._thread_id: Optional[str] = None
+
+        self._circuit_breaker = CircuitBreaker("CodexAppServer", logger=_logger)
+        self._event_queue: asyncio.Queue[RunEvent] = asyncio.Queue()
+
+    async def _ensure_client(self) -> CodexAppServerClient:
+        if self._client is None:
+            self._client = CodexAppServerClient(
+                self._command,
+                cwd=self._cwd,
+                env=self._env,
+                approval_handler=self._handle_approval_request,
+                notification_handler=self._handle_notification,
+            )
+            await self._client.start()
+        return self._client
+
+    async def start_session(self, target: dict, context: dict) -> str:
+        client = await self._ensure_client()
+
+        repo_root = Path(context.get("workspace") or self._cwd or Path.cwd())
+
+        result = await client.thread_start(str(repo_root))
+        self._thread_id = result.get("id")
+
+        if not self._thread_id:
+            raise RuntimeError("Failed to start thread: missing thread ID")
+
+        self._session_id = self._thread_id
+        _logger.info("Started Codex app-server session: %s", self._session_id)
+
+        return self._session_id
+
+    async def run_turn(
+        self, session_id: str, message: str
+    ) -> AsyncGenerator[AgentEvent, None]:
+        client = await self._ensure_client()
+
+        if session_id:
+            self._thread_id = session_id
+
+        if not self._thread_id:
+            await self.start_session(target={}, context={})
+
+        _logger.info(
+            "Running turn on thread %s with message: %s",
+            self._thread_id or "unknown",
+            message[:100],
+        )
+
+        handle = await client.turn_start(
+            self._thread_id if self._thread_id else "default",
+            text=message,
+            approval_policy=self._approval_policy,
+            sandbox_policy=self._sandbox_policy,
+        )
+
+        yield AgentEvent.stream_delta(content=message, delta_type="user_message")
+
+        result = await handle.wait(timeout=600.0)
+
+        for msg in result.agent_messages:
+            yield AgentEvent.stream_delta(content=msg, delta_type="assistant_message")
+
+        for event_data in result.raw_events:
+            yield self._parse_raw_event(event_data)
+
+        yield AgentEvent.message_complete(
+            final_message="\n".join(result.agent_messages)
+        )
+
+    async def run_turn_events(
+        self, session_id: str, message: str
+    ) -> AsyncGenerator[RunEvent, None]:
+        client = await self._ensure_client()
+
+        if session_id:
+            self._thread_id = session_id
+
+        if not self._thread_id:
+            actual_session_id = await self.start_session(target={}, context={})
+        else:
+            actual_session_id = self._thread_id
+
+        _logger.info(
+            "Running turn events on thread %s with message: %s",
+            actual_session_id or "unknown",
+            message[:100],
+        )
+
+        yield Started(timestamp=now_iso(), session_id=actual_session_id)
+
+        yield OutputDelta(
+            timestamp=now_iso(), content=message, delta_type="user_message"
+        )
+
+        self._event_queue = asyncio.Queue()
+
+        handle = await client.turn_start(
+            actual_session_id if actual_session_id else "default",
+            text=message,
+            approval_policy=self._approval_policy,
+            sandbox_policy=self._sandbox_policy,
+        )
+
+        wait_task = asyncio.create_task(handle.wait(timeout=600.0))
+
+        try:
+            while True:
+                if not self._event_queue.empty():
+                    run_event = self._event_queue.get_nowait()
+                    if run_event:
+                        yield run_event
+                    continue
+
+                get_task = asyncio.create_task(self._event_queue.get())
+                done_set, pending_set = await asyncio.wait(
+                    {wait_task, get_task}, return_when=asyncio.FIRST_COMPLETED
+                )
+
+                if wait_task in done_set:
+                    if get_task in pending_set:
+                        get_task.cancel()
+                    result = wait_task.result()
+                    for msg in result.agent_messages:
+                        yield OutputDelta(
+                            timestamp=now_iso(),
+                            content=msg,
+                            delta_type="assistant_message",
+                        )
+                    # raw_events already contain the same notifications we streamed
+                    # through _event_queue; skipping here avoids double-emitting.
+                    while not self._event_queue.empty():
+                        extra = self._event_queue.get_nowait()
+                        if extra:
+                            yield extra
+                    yield Completed(
+                        timestamp=now_iso(),
+                        final_message="\n".join(result.agent_messages),
+                    )
+                    break
+
+                for task in done_set:
+                    if task is not wait_task:
+                        run_event = task.result()
+                        if run_event:
+                            yield run_event
+                for task in pending_set:
+                    task.cancel()
+        except Exception as e:
+            _logger.error("Error during turn execution: %s", e)
+            if not wait_task.done():
+                wait_task.cancel()
+            yield Failed(timestamp=now_iso(), error_message=str(e))
+
+    async def stream_events(self, session_id: str) -> AsyncGenerator[AgentEvent, None]:
+        if False:
+            yield AgentEvent.stream_delta(content="", delta_type="noop")
+
+    async def interrupt(self, session_id: str) -> None:
+        target_thread = session_id or self._thread_id
+        if self._client and target_thread:
+            try:
+                await self._client.turn_interrupt(target_thread)
+                _logger.info("Interrupted turn on thread %s", target_thread)
+            except Exception as e:
+                _logger.warning("Failed to interrupt turn: %s", e)
+
+    async def final_messages(self, session_id: str) -> list[str]:
+        return []
+
+    async def request_approval(
+        self, description: str, context: Optional[Dict[str, Any]] = None
+    ) -> bool:
+        raise NotImplementedError(
+            "Approvals are handled via approval_handler in CodexAppServerBackend"
+        )
+
+    async def _handle_approval_request(
+        self, request: Dict[str, Any]
+    ) -> ApprovalDecision:
+        method = request.get("method", "")
+        item_type = request.get("params", {}).get("type", "")
+
+        _logger.info("Received approval request: %s (type=%s)", method, item_type)
+        request_id = str(request.get("id") or "")
+        # Surface the approval request to consumers (e.g., Telegram) while defaulting to approve
+        await self._event_queue.put(
+            ApprovalRequested(
+                timestamp=now_iso(),
+                request_id=request_id,
+                description=method or "approval requested",
+                context=request.get("params", {}),
+            )
+        )
+
+        return {"approve": True}
+
+    async def _handle_notification(self, notification: Dict[str, Any]) -> None:
+        method = notification.get("method", "")
+        params = notification.get("params", {}) or {}
+        thread_id = params.get("threadId") or params.get("thread_id")
+        if self._thread_id and thread_id and thread_id != self._thread_id:
+            return
+        _logger.debug("Received notification: %s", method)
+        run_event = self._map_to_run_event(notification)
+        if run_event:
+            await self._event_queue.put(run_event)
+
+    def _map_to_run_event(self, event_data: Dict[str, Any]) -> Optional[RunEvent]:
+        method = event_data.get("method", "")
+
+        if method == "turn/streamDelta":
+            content = event_data.get("params", {}).get("delta", "")
+            return OutputDelta(
+                timestamp=now_iso(), content=content, delta_type="assistant_stream"
+            )
+
+        if method == "item/toolCall/start":
+            params = event_data.get("params", {})
+            return ToolCall(
+                timestamp=now_iso(),
+                tool_name=params.get("name", ""),
+                tool_input=params.get("input", {}),
+            )
+
+        if method == "item/toolCall/end":
+            return None
+
+        if method == "turn/error":
+            params = event_data.get("params", {})
+            error_message = params.get("message", "Unknown error")
+            return Failed(timestamp=now_iso(), error_message=error_message)
+
+        return None
+
+    def _parse_raw_event(self, event_data: Dict[str, Any]) -> AgentEvent:
+        method = event_data.get("method", "")
+
+        if method == "turn/streamDelta":
+            content = event_data.get("params", {}).get("delta", "")
+            return AgentEvent.stream_delta(
+                content=content, delta_type="assistant_stream"
+            )
+
+        if method == "item/toolCall/start":
+            params = event_data.get("params", {})
+            return AgentEvent.tool_call(
+                tool_name=params.get("name", ""),
+                tool_input=params.get("input", {}),
+            )
+
+        if method == "item/toolCall/end":
+            params = event_data.get("params", {})
+            return AgentEvent.tool_result(
+                tool_name=params.get("name", ""),
+                result=params.get("result"),
+                error=params.get("error"),
+            )
+
+        if method == "turn/error":
+            params = event_data.get("params", {})
+            error_message = params.get("message", "Unknown error")
+            return AgentEvent.error(error_message=error_message)
+
+        return AgentEvent.stream_delta(content="", delta_type="unknown_event")

codex_autorunner/integrations/agents/opencode_backend.py

@@ -0,0 +1,325 @@
+import json
+import logging
+from typing import Any, AsyncGenerator, Dict, Optional
+
+from ...agents.opencode.client import OpenCodeClient
+from ...agents.opencode.events import SSEEvent
+from .agent_backend import AgentBackend, AgentEvent, AgentEventType, now_iso
+from .run_event import (
+    Completed,
+    Failed,
+    OutputDelta,
+    RunEvent,
+    Started,
+    ToolCall,
+)
+
+_logger = logging.getLogger(__name__)
+
+
+class OpenCodeBackend(AgentBackend):
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        auth: Optional[tuple[str, str]] = None,
+        timeout: Optional[float] = None,
+        agent: Optional[str] = None,
+        model: Optional[dict[str, str]] = None,
+    ):
+        self._client = OpenCodeClient(
+            base_url=base_url,
+            auth=auth,
+            timeout=timeout,
+        )
+        self._agent = agent
+        self._model = model
+
+        self._session_id: Optional[str] = None
+        self._message_count: int = 0
+        self._final_messages: list[str] = []
+
+    async def start_session(self, target: dict, context: dict) -> str:
+        result = await self._client.create_session(
+            title=f"Flow session {self._message_count}",
+            directory=None,
+        )
+
+        self._session_id = result.get("id")
+        if not self._session_id:
+            raise RuntimeError("Failed to create OpenCode session: missing session ID")
+
+        _logger.info("Started OpenCode session: %s", self._session_id)
+
+        return self._session_id
+
+    async def run_turn(
+        self, session_id: str, message: str
+    ) -> AsyncGenerator[AgentEvent, None]:
+        if session_id:
+            self._session_id = session_id
+        if not self._session_id:
+            self._session_id = await self.start_session(target={}, context={})
+
+        _logger.info("Sending message to session %s", self._session_id)
+
+        yield AgentEvent.stream_delta(content=message, delta_type="user_message")
+
+        await self._client.send_message(
+            self._session_id,
+            message=message,
+            agent=self._agent,
+            model=self._model,
+        )
+
+        self._message_count += 1
+        async for event in self._yield_events_until_completion():
+            yield event
+
+    async def run_turn_events(
+        self, session_id: str, message: str
+    ) -> AsyncGenerator[RunEvent, None]:
+        if session_id:
+            self._session_id = session_id
+        if not self._session_id:
+            self._session_id = await self.start_session(target={}, context={})
+
+        _logger.info("Running turn events on session %s", self._session_id)
+
+        yield Started(timestamp=now_iso(), session_id=self._session_id)
+
+        yield OutputDelta(
+            timestamp=now_iso(), content=message, delta_type="user_message"
+        )
+
+        await self._client.send_message(
+            self._session_id,
+            message=message,
+            agent=self._agent,
+            model=self._model,
+        )
+
+        self._message_count += 1
+
+        try:
+            async for run_event in self._yield_run_events_until_completion():
+                yield run_event
+        except Exception as e:
+            _logger.error("Error during turn execution: %s", e)
+            yield Failed(timestamp=now_iso(), error_message=str(e))
+
+    async def stream_events(self, session_id: str) -> AsyncGenerator[AgentEvent, None]:
+        if session_id:
+            self._session_id = session_id
+        if not self._session_id:
+            raise RuntimeError("Session not started. Call start_session() first.")
+
+        async for sse in self._client.stream_events(directory=None):
+            for agent_event in self._convert_sse_to_agent_event(sse):
+                yield agent_event
+
+    async def interrupt(self, session_id: str) -> None:
+        target_session = session_id or self._session_id
+        if target_session:
+            try:
+                await self._client.abort(target_session)
+                _logger.info("Interrupted OpenCode session %s", target_session)
+            except Exception as e:
+                _logger.warning("Failed to interrupt session: %s", e)
+
+    async def final_messages(self, session_id: str) -> list[str]:
+        return self._final_messages
+
+    async def request_approval(
+        self, description: str, context: Optional[Dict[str, Any]] = None
+    ) -> bool:
+        raise NotImplementedError("Approvals not implemented for OpenCodeBackend")
+
+    async def _yield_events_until_completion(self) -> AsyncGenerator[AgentEvent, None]:
+        paths = ["/event", "/global/event"]
+        if self._session_id:
+            paths.insert(0, f"/session/{self._session_id}/event")
+        try:
+            async for sse in self._client.stream_events(
+                directory=None,
+                paths=paths,
+            ):
+                if not self._sse_matches_session(sse):
+                    continue
+                for agent_event in self._convert_sse_to_agent_event(sse):
+                    yield agent_event
+                    if agent_event.event_type in {
+                        AgentEventType.MESSAGE_COMPLETE,
+                        AgentEventType.SESSION_ENDED,
+                    }:
+                        if agent_event.event_type == AgentEventType.MESSAGE_COMPLETE:
+                            self._final_messages.append(
+                                agent_event.data.get("final_message", "")
+                            )
+                        return
+        except Exception as e:
+            _logger.warning("Error in event collection: %s", e)
+            yield AgentEvent.error(error_message=str(e))
+
+    async def _yield_run_events_until_completion(
+        self,
+    ) -> AsyncGenerator[RunEvent, None]:
+        paths = ["/event", "/global/event"]
+        if self._session_id:
+            paths.insert(0, f"/session/{self._session_id}/event")
+        try:
+            async for sse in self._client.stream_events(
+                directory=None,
+                paths=paths,
+            ):
+                if not self._sse_matches_session(sse):
+                    continue
+                for run_event in self._convert_sse_to_run_event(sse):
+                    yield run_event
+                    if isinstance(run_event, (Completed, Failed)):
+                        if isinstance(run_event, Completed):
+                            self._final_messages.append(run_event.final_message)
+                        return
+        except Exception as e:
+            _logger.warning("Error in run event collection: %s", e)
+            yield Failed(timestamp=now_iso(), error_message=str(e))
+
+    def _convert_sse_to_run_event(self, sse: SSEEvent) -> list[RunEvent]:
+        events: list[RunEvent] = []
+
+        try:
+            payload = json.loads(sse.data) if sse.data else {}
+        except json.JSONDecodeError:
+            return events
+
+        payload_type = payload.get("type", "")
+
+        if payload_type == "textDelta":
+            text = payload.get("text", "")
+            events.append(
+                OutputDelta(
+                    timestamp=now_iso(), content=text, delta_type="assistant_stream"
+                )
+            )
+
+        elif payload_type == "toolCall":
+            tool_name = payload.get("toolName", "")
+            tool_input = payload.get("toolInput", {})
+            events.append(
+                ToolCall(
+                    timestamp=now_iso(), tool_name=tool_name, tool_input=tool_input
+                )
+            )
+
+        elif payload_type == "toolCallEnd":
+            pass
+
+        elif payload_type == "messageEnd":
+            final_message = payload.get("message", "")
+            events.append(Completed(timestamp=now_iso(), final_message=final_message))
+
+        elif payload_type == "error":
+            error_message = payload.get("message", "Unknown error")
+            events.append(Failed(timestamp=now_iso(), error_message=error_message))
+
+        elif payload_type == "sessionEnd":
+            # Prefer messageEnd content if we already saw it; otherwise treat as failure.
+            final_message = payload.get("message") or ""
+            if final_message:
+                events.append(
+                    Completed(timestamp=now_iso(), final_message=final_message)
+                )
+            else:
+                events.append(
+                    Failed(
+                        timestamp=now_iso(),
+                        error_message=payload.get("reason", "Session ended early"),
+                    )
+                )
+
+        return events
+
+    def _convert_sse_to_agent_event(self, sse: SSEEvent) -> list[AgentEvent]:
+        events: list[AgentEvent] = []
+
+        try:
+            payload = json.loads(sse.data) if sse.data else {}
+        except json.JSONDecodeError:
+            return events
+
+        payload_type = payload.get("type", "")
+        session_id = self._extract_session_id(payload)
+
+        if payload_type == "textDelta":
+            text = payload.get("text", "")
+            event = AgentEvent.stream_delta(content=text, delta_type="assistant_stream")
+            if session_id:
+                event.data["session_id"] = session_id
+            events.append(event)
+
+        elif payload_type == "toolCall":
+            tool_name = payload.get("toolName", "")
+            tool_input = payload.get("toolInput", {})
+            event = AgentEvent.tool_call(tool_name=tool_name, tool_input=tool_input)
+            if session_id:
+                event.data["session_id"] = session_id
+            events.append(event)
+
+        elif payload_type == "toolCallEnd":
+            tool_name = payload.get("toolName", "")
+            result = payload.get("result")
+            error = payload.get("error")
+            event = AgentEvent.tool_result(
+                tool_name=tool_name, result=result, error=error
+            )
+            if session_id:
+                event.data["session_id"] = session_id
+            events.append(event)
+
+        elif payload_type == "messageEnd":
+            final_message = payload.get("message", "")
+            event = AgentEvent.message_complete(final_message=final_message)
+            if session_id:
+                event.data["session_id"] = session_id
+            events.append(event)
+
+        elif payload_type == "error":
+            error_message = payload.get("message", "Unknown error")
+            event = AgentEvent.error(error_message=error_message)
+            if session_id:
+                event.data["session_id"] = session_id
+            events.append(event)
+
+        elif payload_type == "sessionEnd":
+            events.append(
+                AgentEvent(
+                    type=AgentEventType.SESSION_ENDED.value,
+                    timestamp=now_iso(),
+                    data={
+                        "reason": payload.get("reason", "unknown"),
+                        "session_id": session_id,
+                    },
+                )
+            )
+
+        return events
+
+    def _extract_session_id(self, payload: dict[str, Any]) -> Optional[str]:
+        for key in ("session", "sessionId", "sessionID", "session_id"):
+            value = payload.get(key)
+            if isinstance(value, str):
+                return value
+        return None
+
+    def _sse_matches_session(self, sse: SSEEvent) -> bool:
+        if not self._session_id:
+            return True
+        try:
+            payload = json.loads(sse.data) if sse.data else {}
+        except json.JSONDecodeError:
+            return True
+        session_id = self._extract_session_id(payload)
+        if session_id is None:
+            # If server does not tag events, do not drop them.
+            return True
+        return session_id == self._session_id

codex_autorunner/integrations/agents/run_event.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Union
+
+
+def now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+@dataclass(frozen=True)
+class Started:
+    timestamp: str
+    session_id: str
+
+
+@dataclass(frozen=True)
+class OutputDelta:
+    timestamp: str
+    content: str
+    delta_type: str = "text"
+
+
+@dataclass(frozen=True)
+class ToolCall:
+    timestamp: str
+    tool_name: str
+    tool_input: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class ApprovalRequested:
+    timestamp: str
+    request_id: str
+    description: str
+    context: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class Completed:
+    timestamp: str
+    final_message: str = ""
+
+
+@dataclass(frozen=True)
+class Failed:
+    timestamp: str
+    error_message: str
+
+
+RunEvent = Union[
+    Started,
+    OutputDelta,
+    ToolCall,
+    ApprovalRequested,
+    Completed,
+    Failed,
+]
+
+
+__all__ = [
+    "RunEvent",
+    "Started",
+    "OutputDelta",
+    "ToolCall",
+    "ApprovalRequested",
+    "Completed",
+    "Failed",
+    "now_iso",
+]