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

codex_autorunner/surfaces/web/routes/file_chat.py

@@ -14,13 +14,14 @@ import difflib
 import logging
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, AsyncIterator, Dict, Optional
+from typing import Any, AsyncIterator, Callable, Dict, Optional
 
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import StreamingResponse
 
 from ....agents.registry import validate_agent_id
 from ....core import drafts as draft_utils
+from ....core.context_awareness import CAR_AWARENESS_BLOCK, format_file_role_addendum
 from ....core.state import now_iso
 from ....core.utils import atomic_write, find_repo_root
 from ....integrations.app_server.event_buffer import format_sse
@@ -140,7 +141,49 @@ def _parse_target(repo_root: Path, raw: str) -> _Target:
             state_key=f"workspace_{rel_suffix.replace('/', '_')}",
         )
 
-    raise HTTPException(status_code=400, detail="invalid target")
+    raise HTTPException(status_code=400, detail=f"invalid target: {target}")
+
+
+def _build_file_chat_prompt(*, target: _Target, message: str, before: str) -> str:
+    if target.kind == "ticket":
+        file_role_context = (
+            f"{format_file_role_addendum('ticket', target.rel_path)}\n"
+            "Edits here change what the ticket flow agent will do; keep YAML "
+            "frontmatter valid."
+        )
+    elif target.kind == "workspace":
+        file_role_context = (
+            f"{format_file_role_addendum('workspace', target.rel_path)}\n"
+            "These docs act as shared memory across ticket turns."
+        )
+    else:
+        file_role_context = format_file_role_addendum("other", target.rel_path)
+
+    return (
+        f"{CAR_AWARENESS_BLOCK}\n\n"
+        "<file_role_context>\n"
+        f"{file_role_context}\n"
+        "</file_role_context>\n\n"
+        "You are editing a single file in Codex Autorunner.\n\n"
+        "<target>\n"
+        f"{target.target}\n"
+        "</target>\n\n"
+        "<path>\n"
+        f"{target.rel_path}\n"
+        "</path>\n\n"
+        "<instructions>\n"
+        "- This is a single-turn edit request. Don’t ask the user questions.\n"
+        "- You may read other files for context, but only modify the target file.\n"
+        "- If no changes are needed, explain why without editing the file.\n"
+        "- Respond with a short summary of what you did.\n"
+        "</instructions>\n\n"
+        "<user_request>\n"
+        f"{message}\n"
+        "</user_request>\n\n"
+        "<FILE_CONTENT>\n"
+        f"{before[:12000]}\n"
+        "</FILE_CONTENT>\n"
+    )
 
 
 def _read_file(path: Path) -> str:
@@ -164,6 +207,10 @@ def build_file_chat_routes() -> APIRouter:
     router = APIRouter(prefix="/api", tags=["file-chat"])
     _active_chats: Dict[str, asyncio.Event] = {}
     _chat_lock = asyncio.Lock()
+    _turn_lock = asyncio.Lock()
+    _current_by_target: Dict[str, Dict[str, Any]] = {}
+    _current_by_client: Dict[str, Dict[str, Any]] = {}
+    _last_by_client: Dict[str, Dict[str, Any]] = {}
 
     async def _get_or_create_interrupt_event(key: str) -> asyncio.Event:
         async with _chat_lock:
@@ -175,6 +222,61 @@ def build_file_chat_routes() -> APIRouter:
         async with _chat_lock:
             _active_chats.pop(key, None)
 
+    async def _begin_turn_state(target: _Target, client_turn_id: Optional[str]) -> None:
+        async with _turn_lock:
+            state: Dict[str, Any] = {
+                "client_turn_id": client_turn_id or "",
+                "target": target.target,
+                "status": "starting",
+                "agent": None,
+                "thread_id": None,
+                "turn_id": None,
+            }
+            _current_by_target[target.state_key] = state
+            if client_turn_id:
+                _current_by_client[client_turn_id] = state
+
+    async def _update_turn_state(target: _Target, **updates: Any) -> None:
+        async with _turn_lock:
+            state = _current_by_target.get(target.state_key)
+            if not state:
+                return
+            for key, value in updates.items():
+                if value is None:
+                    continue
+                state[key] = value
+            cid = state.get("client_turn_id") or ""
+            if cid:
+                _current_by_client[cid] = state
+
+    async def _finalize_turn_state(target: _Target, result: Dict[str, Any]) -> None:
+        async with _turn_lock:
+            state = _current_by_target.pop(target.state_key, None)
+            cid = ""
+            if state:
+                cid = state.get("client_turn_id", "") or ""
+            if cid:
+                _current_by_client.pop(cid, None)
+                _last_by_client[cid] = dict(result or {})
+
+    async def _active_for_client(client_turn_id: Optional[str]) -> Dict[str, Any]:
+        if not client_turn_id:
+            return {}
+        async with _turn_lock:
+            return dict(_current_by_client.get(client_turn_id, {}))
+
+    async def _last_for_client(client_turn_id: Optional[str]) -> Dict[str, Any]:
+        if not client_turn_id:
+            return {}
+        async with _turn_lock:
+            return dict(_last_by_client.get(client_turn_id, {}))
+
+    @router.get("/file-chat/active")
+    async def file_chat_active(client_turn_id: Optional[str] = None) -> Dict[str, Any]:
+        current = await _active_for_client(client_turn_id)
+        last = await _last_for_client(client_turn_id)
+        return {"active": bool(current), "current": current, "last_result": last}
+
     @router.post("/file-chat")
     async def chat_file(request: Request):
         """Chat with a file target - optionally streams SSE events."""
@@ -185,6 +287,7 @@ def build_file_chat_routes() -> APIRouter:
         agent = body.get("agent", "codex")
         model = body.get("model")
         reasoning = body.get("reasoning")
+        client_turn_id = (body.get("client_turn_id") or "").strip() or None
 
         if not message:
             raise HTTPException(status_code=400, detail="message is required")
@@ -203,6 +306,8 @@ def build_file_chat_routes() -> APIRouter:
                 raise HTTPException(status_code=409, detail="File chat already running")
             _active_chats[target.state_key] = asyncio.Event()
 
+        await _begin_turn_state(target, client_turn_id)
+
         if stream:
             return StreamingResponse(
                 _stream_file_chat(
@@ -213,21 +318,47 @@ def build_file_chat_routes() -> APIRouter:
                     agent=agent,
                     model=model,
                     reasoning=reasoning,
+                    client_turn_id=client_turn_id,
                 ),
                 media_type="text/event-stream",
                 headers=SSE_HEADERS,
             )
 
         try:
-            result = await _execute_file_chat(
-                request,
-                repo_root,
-                target,
-                message,
-                agent=agent,
-                model=model,
-                reasoning=reasoning,
-            )
+            result: Dict[str, Any]
+
+            async def _on_meta(agent_id: str, thread_id: str, turn_id: str) -> None:
+                await _update_turn_state(
+                    target,
+                    agent=agent_id,
+                    thread_id=thread_id,
+                    turn_id=turn_id,
+                )
+
+            try:
+                result = await _execute_file_chat(
+                    request,
+                    repo_root,
+                    target,
+                    message,
+                    agent=agent,
+                    model=model,
+                    reasoning=reasoning,
+                    on_meta=_on_meta,
+                )
+            except Exception as exc:
+                await _finalize_turn_state(
+                    target,
+                    {
+                        "status": "error",
+                        "detail": str(exc),
+                        "client_turn_id": client_turn_id or "",
+                    },
+                )
+                raise
+            result = dict(result or {})
+            result["client_turn_id"] = client_turn_id or ""
+            await _finalize_turn_state(target, result)
             return result
         finally:
             await _clear_interrupt_event(target.state_key)
@@ -241,22 +372,62 @@ def build_file_chat_routes() -> APIRouter:
         agent: str = "codex",
         model: Optional[str] = None,
         reasoning: Optional[str] = None,
+        client_turn_id: Optional[str] = None,
     ) -> AsyncIterator[str]:
         yield format_sse("status", {"status": "queued"})
         try:
-            result = await _execute_file_chat(
-                request,
-                repo_root,
-                target,
-                message,
-                agent=agent,
-                model=model,
-                reasoning=reasoning,
+
+            async def _on_meta(agent_id: str, thread_id: str, turn_id: str) -> None:
+                await _update_turn_state(
+                    target,
+                    agent=agent_id,
+                    thread_id=thread_id,
+                    turn_id=turn_id,
+                )
+
+            run_task = asyncio.create_task(
+                _execute_file_chat(
+                    request,
+                    repo_root,
+                    target,
+                    message,
+                    agent=agent,
+                    model=model,
+                    reasoning=reasoning,
+                    on_meta=_on_meta,
+                )
             )
+
+            async def _finalize() -> None:
+                result = {"status": "error", "detail": "File chat failed"}
+                try:
+                    result = await run_task
+                except Exception as exc:
+                    logger.exception("file chat task failed")
+                    result = {
+                        "status": "error",
+                        "detail": str(exc) or "File chat failed",
+                    }
+                result = dict(result or {})
+                result["client_turn_id"] = client_turn_id or ""
+                await _finalize_turn_state(target, result)
+
+            asyncio.create_task(_finalize())
+
+            try:
+                result = await asyncio.shield(run_task)
+            except asyncio.CancelledError:
+                # client disconnected; turn continues in background
+                return
+
             if result.get("status") == "ok":
                 raw_events = result.pop("raw_events", []) or []
                 for event in raw_events:
                     yield format_sse("app-server", event)
+                usage_parts = result.pop("usage_parts", []) or []
+                for usage in usage_parts:
+                    yield format_sse("token_usage", usage)
+                result["client_turn_id"] = client_turn_id or ""
                 yield format_sse("update", result)
                 yield format_sse("done", {"status": "ok"})
             elif result.get("status") == "interrupted":
@@ -283,11 +454,14 @@ def build_file_chat_routes() -> APIRouter:
         agent: str = "codex",
         model: Optional[str] = None,
         reasoning: Optional[str] = None,
+        on_meta: Optional[Callable[[str, str, str], Any]] = None,
+        on_usage: Optional[Callable[[Dict[str, Any]], Any]] = None,
     ) -> Dict[str, Any]:
         supervisor = getattr(request.app.state, "app_server_supervisor", None)
         threads = getattr(request.app.state, "app_server_threads", None)
         opencode = getattr(request.app.state, "opencode_supervisor", None)
         engine = getattr(request.app.state, "engine", None)
+        events = getattr(request.app.state, "app_server_events", None)
         stall_timeout_seconds = None
         try:
             stall_timeout_seconds = (
@@ -303,21 +477,7 @@ def build_file_chat_routes() -> APIRouter:
         before = _read_file(target.path)
         base_hash = _hash_content(before)
 
-        prompt = (
-            "You are editing a single file in Codex AutoRunner.\n\n"
-            f"Target: {target.target}\n"
-            f"Path: {target.rel_path}\n\n"
-            "Instructions:\n"
-            "- This run is non-interactive. Do not ask the user questions.\n"
-            "- Edit ONLY the target file.\n"
-            "- If no changes are needed, explain why without editing the file.\n"
-            "- Respond with a short summary of what you did.\n\n"
-            "User request:\n"
-            f"{message}\n\n"
-            "<FILE_CONTENT>\n"
-            f"{before[:12000]}\n"
-            "</FILE_CONTENT>\n"
-        )
+        prompt = _build_file_chat_prompt(target=target, message=message, before=before)
 
         interrupt_event = await _get_or_create_interrupt_event(target.state_key)
         if interrupt_event.is_set():
@@ -329,6 +489,7 @@ def build_file_chat_routes() -> APIRouter:
             agent_id = "codex"
 
         thread_key = f"file_chat.{target.state_key}"
+        await _update_turn_state(target, status="running", agent=agent_id)
 
         if agent_id == "opencode":
             if opencode is None:
@@ -343,6 +504,8 @@ def build_file_chat_routes() -> APIRouter:
                 thread_registry=threads,
                 thread_key=thread_key,
                 stall_timeout_seconds=stall_timeout_seconds,
+                on_meta=on_meta,
+                on_usage=on_usage,
             )
         else:
             if supervisor is None:
@@ -355,10 +518,13 @@ def build_file_chat_routes() -> APIRouter:
                 repo_root,
                 prompt,
                 interrupt_event,
+                agent_id=agent_id,
                 model=model,
                 reasoning=reasoning,
                 thread_registry=threads,
                 thread_key=thread_key,
+                on_meta=on_meta,
+                events=events,
             )
 
         if result.get("status") != "ok":
@@ -393,6 +559,7 @@ def build_file_chat_routes() -> APIRouter:
             return {
                 "status": "ok",
                 "target": target.target,
+                "agent": agent_id,
                 "agent_message": agent_message,
                 "message": response_text,
                 "has_draft": True,
@@ -400,6 +567,8 @@ def build_file_chat_routes() -> APIRouter:
                 "content": after,
                 "base_hash": base_hash,
                 "created_at": drafts[target.state_key]["created_at"],
+                "thread_id": result.get("thread_id"),
+                "turn_id": result.get("turn_id"),
                 **(
                     {"raw_events": result.get("raw_events")}
                     if result.get("raw_events")
@@ -410,9 +579,12 @@ def build_file_chat_routes() -> APIRouter:
         return {
             "status": "ok",
             "target": target.target,
+            "agent": agent_id,
             "agent_message": agent_message,
             "message": response_text,
             "has_draft": False,
+            "thread_id": result.get("thread_id"),
+            "turn_id": result.get("turn_id"),
             **(
                 {"raw_events": result.get("raw_events")}
                 if result.get("raw_events")
@@ -428,8 +600,11 @@ def build_file_chat_routes() -> APIRouter:
         *,
         model: Optional[str] = None,
         reasoning: Optional[str] = None,
+        agent_id: str = "codex",
         thread_registry: Optional[Any] = None,
         thread_key: Optional[str] = None,
+        on_meta: Optional[Callable[[str, str, str], Any]] = None,
+        events: Optional[Any] = None,
     ) -> Dict[str, Any]:
         client = await supervisor.get_client(repo_root)
 
@@ -463,6 +638,18 @@ def build_file_chat_routes() -> APIRouter:
             sandbox_policy="dangerFullAccess",
             **turn_kwargs,
         )
+        if events is not None:
+            try:
+                await events.register_turn(thread_id, handle.turn_id)
+            except Exception:
+                logger.debug("file chat register_turn failed", exc_info=True)
+        if on_meta is not None:
+            try:
+                maybe = on_meta(agent_id, thread_id, handle.turn_id)
+                if asyncio.iscoroutine(maybe):
+                    await maybe
+            except Exception:
+                logger.debug("file chat meta callback failed", exc_info=True)
 
         turn_task = asyncio.create_task(handle.wait(timeout=None))
         timeout_task = asyncio.create_task(asyncio.sleep(FILE_CHAT_TIMEOUT_SECONDS))
@@ -495,6 +682,9 @@ def build_file_chat_routes() -> APIRouter:
             "agent_message": agent_message,
             "message": output,
             "raw_events": raw_events,
+            "thread_id": thread_id,
+            "turn_id": getattr(handle, "turn_id", None),
+            "agent": agent_id,
         }
 
     async def _execute_opencode(
@@ -508,9 +698,12 @@ def build_file_chat_routes() -> APIRouter:
         thread_registry: Optional[Any] = None,
         thread_key: Optional[str] = None,
         stall_timeout_seconds: Optional[float] = None,
+        on_meta: Optional[Callable[[str, str, str], Any]] = None,
+        on_usage: Optional[Callable[[Dict[str, Any]], Any]] = None,
     ) -> Dict[str, Any]:
         from ....agents.opencode.runtime import (
             PERMISSION_ALLOW,
+            build_turn_id,
             collect_opencode_output,
             extract_session_id,
             parse_message_response,
@@ -529,9 +722,32 @@ def build_file_chat_routes() -> APIRouter:
             if thread_registry is not None and thread_key:
                 thread_registry.set_thread_id(thread_key, session_id)
 
+        turn_id = build_turn_id(session_id)
+        if on_meta is not None:
+            try:
+                maybe = on_meta("opencode", session_id, turn_id)
+                if asyncio.iscoroutine(maybe):
+                    await maybe
+            except Exception:
+                logger.debug("file chat opencode meta failed", exc_info=True)
+
         model_payload = split_model_id(model)
         await supervisor.mark_turn_started(repo_root)
 
+        usage_parts: list[Dict[str, Any]] = []
+
+        async def _part_handler(
+            part_type: str, part: Any, turn_id_arg: Optional[str] | None
+        ) -> None:
+            if part_type == "usage" and on_usage is not None:
+                usage_parts.append(part)
+                try:
+                    maybe = on_usage(part)
+                    if asyncio.iscoroutine(maybe):
+                        await maybe
+                except Exception:
+                    logger.debug("file chat usage handler failed", exc_info=True)
+
         ready_event = asyncio.Event()
         output_task = asyncio.create_task(
             collect_opencode_output(
@@ -543,6 +759,7 @@ def build_file_chat_routes() -> APIRouter:
                 question_policy="auto_first_option",
                 should_stop=interrupt_event.is_set,
                 ready_event=ready_event,
+                part_handler=_part_handler,
                 stall_timeout_seconds=stall_timeout_seconds,
             )
         )
@@ -593,11 +810,17 @@ def build_file_chat_routes() -> APIRouter:
         if output_result.error:
             raise FileChatError(output_result.error)
         agent_message = _parse_agent_message(output_result.text)
-        return {
+        result = {
             "status": "ok",
             "agent_message": agent_message,
             "message": output_result.text,
+            "thread_id": session_id,
+            "turn_id": turn_id,
+            "agent": "opencode",
         }
+        if usage_parts:
+            result["usage_parts"] = usage_parts
+        return result
 
     def _parse_agent_message(output: str) -> str:
         text = (output or "").strip()
@@ -693,6 +916,37 @@ def build_file_chat_routes() -> APIRouter:
             "content": _read_file(resolved.path),
         }
 
+    @router.get("/file-chat/turns/{turn_id}/events")
+    async def stream_file_chat_turn_events(
+        turn_id: str, request: Request, thread_id: str, agent: str = "codex"
+    ):
+        agent_id = (agent or "").strip().lower()
+        if agent_id == "codex":
+            events = getattr(request.app.state, "app_server_events", None)
+            if events is None:
+                raise HTTPException(status_code=404, detail="Events unavailable")
+            if not thread_id:
+                raise HTTPException(status_code=400, detail="thread_id is required")
+            return StreamingResponse(
+                events.stream(thread_id, turn_id),
+                media_type="text/event-stream",
+                headers=SSE_HEADERS,
+            )
+        if agent_id == "opencode":
+            supervisor = getattr(request.app.state, "opencode_supervisor", None)
+            if supervisor is None:
+                raise HTTPException(status_code=404, detail="OpenCode unavailable")
+            from ....agents.opencode.harness import OpenCodeHarness
+
+            harness = OpenCodeHarness(supervisor)
+            repo_root = _resolve_repo_root(request)
+            return StreamingResponse(
+                harness.stream_events(repo_root, thread_id, turn_id),
+                media_type="text/event-stream",
+                headers=SSE_HEADERS,
+            )
+        raise HTTPException(status_code=404, detail="Unknown agent")
+
     @router.post("/file-chat/interrupt")
     async def interrupt_file_chat(request: Request):
         body = await request.json()
@@ -715,6 +969,7 @@ def build_file_chat_routes() -> APIRouter:
         agent = body.get("agent", "codex")
         model = body.get("model")
         reasoning = body.get("reasoning")
+        client_turn_id = (body.get("client_turn_id") or "").strip() or None
 
         if not message:
             raise HTTPException(status_code=400, detail="message is required")
@@ -729,6 +984,7 @@ def build_file_chat_routes() -> APIRouter:
                     status_code=409, detail="Ticket chat already running"
                 )
             _active_chats[target.state_key] = asyncio.Event()
+        await _begin_turn_state(target, client_turn_id)
 
         if stream:
             return StreamingResponse(
@@ -740,13 +996,14 @@ def build_file_chat_routes() -> APIRouter:
                     agent=agent,
                     model=model,
                     reasoning=reasoning,
+                    client_turn_id=client_turn_id,
                 ),
                 media_type="text/event-stream",
                 headers=SSE_HEADERS,
             )
 
         try:
-            return await _execute_file_chat(
+            result = await _execute_file_chat(
                 request,
                 repo_root,
                 target,
@@ -755,6 +1012,10 @@ def build_file_chat_routes() -> APIRouter:
                 model=model,
                 reasoning=reasoning,
             )
+            result = dict(result or {})
+            result["client_turn_id"] = client_turn_id or ""
+            await _finalize_turn_state(target, result)
+            return result
         finally:
             await _clear_interrupt_event(target.state_key)