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

codex_autorunner/integrations/telegram/handlers/commands/execution.py

@@ -27,6 +27,7 @@ from .....agents.opencode.runtime import (
     split_model_id,
 )
 from .....agents.opencode.supervisor import OpenCodeSupervisorError
+from .....core.about_car import CAR_CONTEXT_HINT, CAR_CONTEXT_KEYWORDS
 from .....core.config import load_repo_config
 from .....core.injected_context import wrap_injected_context
 from .....core.logging_utils import log_event
@@ -46,7 +47,6 @@ from ...constants import (
     DEFAULT_INTERRUPT_TIMEOUT_SECONDS,
     MAX_MENTION_BYTES,
     MAX_TOPIC_THREAD_HISTORY,
-    OPENCODE_TURN_TIMEOUT_SECONDS,
     PLACEHOLDER_TEXT,
     QUEUED_PLACEHOLDER_TEXT,
     RESUME_PREVIEW_ASSISTANT_LIMIT,
@@ -94,20 +94,6 @@ OUTBOX_CONTEXT_RE = re.compile(
     re.IGNORECASE,
 )
 
-CAR_CONTEXT_KEYWORDS = (
-    "car",
-    "codex",
-    "todo",
-    "progress",
-    "opinions",
-    "spec",
-    "summary",
-    "autorunner",
-    "work docs",
-)
-CAR_CONTEXT_HINT = (
-    "Context: read .codex-autorunner/ABOUT_CAR.md for repo-specific rules."
-)
 
 FILES_HINT_TEMPLATE = (
     "Inbox: {inbox}\n"
@@ -1692,6 +1678,7 @@ class ExecutionCommands(SharedHelpers):
                             opencode_client,
                             session_id=thread_id,
                             workspace_path=str(workspace_root),
+                            model_payload=model_payload,
                             progress_session_ids=watched_session_ids,
                             permission_policy=permission_policy,
                             permission_handler=(
@@ -1719,9 +1706,14 @@ class ExecutionCommands(SharedHelpers):
                         codex_thread_id=thread_id,
                         sse_ready_ms=sse_ready_ms,
                     )
-                    timeout_task = asyncio.create_task(
-                        asyncio.sleep(OPENCODE_TURN_TIMEOUT_SECONDS)
+                    timeout_seconds = self._config.agent_turn_timeout_seconds.get(
+                        "opencode"
                     )
+                    timeout_task: Optional[asyncio.Task] = None
+                    if timeout_seconds is not None and timeout_seconds > 0:
+                        timeout_task = asyncio.create_task(
+                            asyncio.sleep(timeout_seconds)
+                        )
                     prompt_sent_at = time.monotonic()
                     prompt_task = asyncio.create_task(
                         opencode_client.prompt_async(
@@ -1745,52 +1737,54 @@ class ExecutionCommands(SharedHelpers):
                             endpoint="/session/{id}/prompt_async",
                         )
                     except Exception as exc:
-                        timeout_task.cancel()
-                        with suppress(asyncio.CancelledError):
-                            await timeout_task
+                        if timeout_task is not None:
+                            timeout_task.cancel()
+                            with suppress(asyncio.CancelledError):
+                                await timeout_task
                         output_task.cancel()
                         with suppress(asyncio.CancelledError):
                             await output_task
                         raise exc
-                    done, _pending = await asyncio.wait(
-                        {output_task, timeout_task},
-                        return_when=asyncio.FIRST_COMPLETED,
-                    )
-                    if timeout_task in done:
-                        runtime.interrupt_requested = True
-                        await _abort_opencode()
-                        output_task.cancel()
-                        with suppress(asyncio.CancelledError):
-                            await output_task
+                    if timeout_task is not None:
+                        done, _pending = await asyncio.wait(
+                            {output_task, timeout_task},
+                            return_when=asyncio.FIRST_COMPLETED,
+                        )
+                        if timeout_task in done:
+                            runtime.interrupt_requested = True
+                            await _abort_opencode()
+                            output_task.cancel()
+                            with suppress(asyncio.CancelledError):
+                                await output_task
+                            timeout_task.cancel()
+                            with suppress(asyncio.CancelledError):
+                                await timeout_task
+                            turn_elapsed_seconds = time.monotonic() - turn_started_at
+                            completion_mode = (
+                                "timeout"
+                                if not runtime.interrupt_requested
+                                else "interrupt"
+                            )
+                            log_event(
+                                self._logger,
+                                logging.INFO,
+                                "telegram.opencode.completed",
+                                topic_key=key,
+                                chat_id=message.chat_id,
+                                thread_id=message.thread_id,
+                                codex_thread_id=thread_id,
+                                completion_mode=completion_mode,
+                                elapsed_seconds=turn_elapsed_seconds,
+                            )
+                            return _TurnRunFailure(
+                                "OpenCode turn timed out.",
+                                placeholder_id,
+                                transcript_message_id,
+                                transcript_text,
+                            )
                         timeout_task.cancel()
                         with suppress(asyncio.CancelledError):
                             await timeout_task
-                        turn_elapsed_seconds = time.monotonic() - turn_started_at
-                        completion_mode = (
-                            "timeout"
-                            if not runtime.interrupt_requested
-                            else "interrupt"
-                        )
-                        log_event(
-                            self._logger,
-                            logging.INFO,
-                            "telegram.opencode.completed",
-                            topic_key=key,
-                            chat_id=message.chat_id,
-                            thread_id=message.thread_id,
-                            codex_thread_id=thread_id,
-                            completion_mode=completion_mode,
-                            elapsed_seconds=turn_elapsed_seconds,
-                        )
-                        return _TurnRunFailure(
-                            "OpenCode turn timed out.",
-                            placeholder_id,
-                            transcript_message_id,
-                            transcript_text,
-                        )
-                    timeout_task.cancel()
-                    with suppress(asyncio.CancelledError):
-                        await timeout_task
                     output_result = await output_task
                     turn_elapsed_seconds = time.monotonic() - turn_started_at
                     log_event(
@@ -2225,7 +2219,9 @@ class ExecutionCommands(SharedHelpers):
                 result = await self._wait_for_turn_result(
                     client,
                     turn_handle,
-                    timeout_seconds=self._config.app_server_turn_timeout_seconds,
+                    timeout_seconds=self._config.agent_turn_timeout_seconds.get(
+                        "codex"
+                    ),
                     topic_key=key,
                     chat_id=message.chat_id,
                     thread_id=message.thread_id,

codex_autorunner/integrations/telegram/handlers/commands/files.py

@@ -8,7 +8,7 @@ import secrets
 import time
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional, Sequence
+from typing import Any, Optional, Sequence
 
 from .....core.injected_context import wrap_injected_context
 from .....core.logging_utils import log_event
@@ -16,13 +16,10 @@ from .....core.state import now_iso
 from ...adapter import TelegramMessage
 from ...config import TelegramMediaCandidate
 from ...helpers import _path_within
+from ...state import PendingVoiceRecord, TelegramTopicRecord
 from .. import messages as message_handlers
 from .shared import SharedHelpers
 
-if TYPE_CHECKING:
-    from ...state import PendingVoiceRecord, TelegramTopicRecord
-
-
 FILES_HINT_TEMPLATE = (
     "Inbox: {inbox}\n"
     "Outbox (pending): {outbox}\n"
@@ -100,7 +97,6 @@ class MediaBatchResult:
 
 
 class FilesCommands(SharedHelpers):
-
     def _format_telegram_download_error(self, exc: Exception) -> Optional[str]:
         for current in _iter_exception_chain(exc):
             if isinstance(current, Exception):