mycode-cli 0.18.0__py3-none-any.whl → 0.19.1__py3-none-any.whl

mycode_cli/runtime.py

@@ -5,26 +5,21 @@ from __future__ import annotations
 from mycode.agent import Agent
 from mycode_cli.config import ResolvedProvider, Settings
 from mycode_cli.permissions import ToolReviewCallback, build_permission_hooks
-from mycode_cli.sessions import SessionStore, sum_session_cost
+from mycode_cli.sessions import SessionStore, SessionTotals, sum_session_totals
 from mycode_cli.system_prompt import build_system_prompt
 from mycode_cli.tools import DEFAULT_TOOLS
 from mycode_cli.web_tools import build_web_tools
 from mycode_cli.workspace import CliDeps
 
 
-def sum_known_costs(*costs: float | None) -> float | None:
-    known = [cost for cost in costs if cost is not None]
-    return sum(known) if known else None
+async def load_session_totals(store: SessionStore, session_id: str) -> SessionTotals:
+    """Load the session's cumulative usage and USD cost from its raw JSONL timeline.
 
-
-async def load_session_cost(store: SessionStore, session_id: str) -> float | None:
-    """Load the session's cumulative USD cost from its raw JSONL timeline.
-
-    Counts persisted costs from tool loops, compact summaries, and turns
-    discarded by rewind. Records without a cost are skipped.
+    Counts tool loops, compact summaries, and turns discarded by rewind.
+    Records without usage or cost contribute nothing to that total.
     """
 
-    return sum_session_cost(await store.load_raw_messages(session_id))
+    return sum_session_totals(await store.load_raw_messages(session_id))
 
 
 def build_agent(

mycode_cli/server/routers/chat.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import io
 import json
 import os
 from base64 import b64encode
@@ -10,6 +11,7 @@ from collections.abc import AsyncIterator
 from dataclasses import replace
 from pathlib import Path
 from typing import Annotated, Any, cast
+from uuid import uuid4
 
 from fastapi import APIRouter, HTTPException, Query, Request
 from fastapi import Path as PathParam
@@ -21,7 +23,7 @@ from mycode.attachments import (
     detect_document_mime_type,
     detect_image_mime_type,
 )
-from mycode.compact import has_compactable_history
+from mycode.compact import DEFAULT_COMPACT_THRESHOLD, has_compactable_history
 from mycode.messages import (
     ConversationMessage,
     build_message,
@@ -30,6 +32,7 @@ from mycode.messages import (
     image_block,
     text_block,
 )
+from mycode.models import ModelMetadata
 from mycode_cli.config import (
     ResolvedProvider,
     get_settings,
@@ -40,22 +43,25 @@ from mycode_cli.config import (
     resolve_provider_choices,
 )
 from mycode_cli.permissions import ToolReviewDecision, ToolReviewRequest
-from mycode_cli.runtime import build_agent, load_session_cost
+from mycode_cli.runtime import build_agent, load_session_totals
 from mycode_cli.server.deps import RunManagerDep, StoreDep, resolve_workspace_cwd
-from mycode_cli.server.run_manager import ActiveRunError
+from mycode_cli.server.run_manager import ActiveRunError, RunAgent
 from mycode_cli.server.schemas import (
     CancelRunResponse,
     ChatRequest,
     ChatResponse,
     CompactRequest,
-    CompactResponse,
     DecideRequest,
+    PendingInputRequest,
     RunInfo,
+    RunResponse,
     StatusResponse,
     StreamEvent,
+    UserInputRequest,
 )
 from mycode_cli.system_prompt import build_skill_snapshot_blocks, discover_slash_skills
-from mycode_cli.workspace import resolve_path
+from mycode_cli.tools import read_text_window
+from mycode_cli.workspace import CliDeps, resolve_path
 
 router = APIRouter()
 
@@ -69,7 +75,7 @@ def _resolve_workspace_attachment_path(rel_path: str, *, cwd: str) -> Path:
 
 
 def _read_workspace_text_attachment(rel_path: str, *, name: str | None, cwd: str) -> list[dict[str, Any]]:
-    """Read a workspace text file selected via the @ menu into a `<file>` block.
+    """Read a workspace text file selected via the @ menu into a `<file>` block, bounded like ``read``.
 
     Re-validates the path at send time: it must resolve inside ``cwd`` (guards
     against a symlink swapped in after selection), be a regular file, and be
@@ -81,16 +87,40 @@ def _read_workspace_text_attachment(rel_path: str, *, name: str | None, cwd: str
     if detect_image_mime_type(path) or detect_document_mime_type(path):
         raise HTTPException(status_code=400, detail=f"not a text file: {rel_path}")
     try:
-        return build_attachment_blocks([Attachment.path(path, name=name or rel_path)])
-    except ValueError as exc:
-        raise HTTPException(status_code=400, detail=str(exc)) from exc
+        with path.open(encoding="utf-8") as file:
+            window = read_text_window(file)
+    except UnicodeDecodeError as exc:
+        raise HTTPException(status_code=400, detail=f"not UTF-8 text: {rel_path}") from exc
+    return build_attachment_blocks([Attachment.text(window.render(path), name=name or rel_path)])
+
+
+def _write_uploads(uploads: dict[Path, str]) -> None:
+    for path, text in uploads.items():
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text, encoding="utf-8")
+
+
+def _remove_uploads(uploads: dict[Path, str]) -> None:
+    """Undo ``_write_uploads`` for a message the run refused."""
+
+    for path in uploads:
+        path.unlink(missing_ok=True)
 
 
-async def _build_user_message(chat: ChatRequest, cwd: str) -> ConversationMessage:
+async def _build_user_message(chat: UserInputRequest, deps: CliDeps) -> tuple[ConversationMessage, dict[Path, str]]:
+    """Build the user message and the uploads to save before it is sent.
+
+    A text upload that does not fit one read window is shown truncated, and its
+    full text is returned for ``tool_output_dir`` so the model can read the rest.
+    The caller writes it once the request has passed validation.
+    """
+
+    cwd = str(deps.cwd)
+    uploads: dict[Path, str] = {}
     if not chat.input:
         text = str(chat.message or "").strip()
         snapshots = await asyncio.to_thread(build_skill_snapshot_blocks, text, cwd)
-        return build_message("user", [*snapshots, text_block(text)])
+        return build_message("user", [*snapshots, text_block(text)]), uploads
 
     blocks: list[dict[str, Any]] = []
     visible_text: list[str] = []
@@ -103,7 +133,12 @@ async def _build_user_message(chat: ChatRequest, cwd: str) -> ConversationMessag
                 continue
             text = block.text or ""
             if block.is_attachment:
-                blocks.extend(build_attachment_blocks([Attachment.text(text, name=str(block.name or "attached-file"))]))
+                name = str(block.name or "attached-file")
+                window = read_text_window(io.StringIO(text, newline=None))
+                upload_path = deps.tool_output_dir / f"upload-{uuid4().hex}"
+                if window.partial:
+                    uploads[upload_path] = text
+                blocks.extend(build_attachment_blocks([Attachment.text(window.render(upload_path), name=name)]))
             elif text:
                 visible_text.append(text)
                 blocks.append(text_block(text))
@@ -140,7 +175,15 @@ async def _build_user_message(chat: ChatRequest, cwd: str) -> ConversationMessag
         raise HTTPException(status_code=400, detail="input must include at least one non-empty block")
     snapshots = await asyncio.to_thread(build_skill_snapshot_blocks, "\n".join(visible_text), cwd)
     blocks[:0] = snapshots
-    return build_message("user", blocks)
+    return build_message("user", blocks), uploads
+
+
+def _check_input_support(message: ConversationMessage, model: ModelMetadata | RunAgent) -> None:
+    content_types = {b.get("type") for b in (message.get("content") or []) if isinstance(b, dict)}
+    if "image" in content_types and not model.supports_image_input:
+        raise HTTPException(status_code=400, detail="current model does not support image input")
+    if "document" in content_types and not model.supports_pdf_input:
+        raise HTTPException(status_code=400, detail="current model does not support PDF input")
 
 
 def _validate_rewind_request(
@@ -182,7 +225,9 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep) -> ChatR
         api_base=chat.api_base,
     )
     session_id = chat.session_id or "default"
-    user_message = await _build_user_message(chat, cwd)
+    user_message, uploads = await _build_user_message(
+        chat, CliDeps.for_session(cwd=cwd, data_dir=store.data_dir, session_id=session_id)
+    )
 
     # Capability check before any disk mutation — a failed check must not
     # leave an empty session on disk or land a premature rewind marker.
@@ -192,11 +237,7 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep) -> ChatR
         model=resolved.model,
         model_config=model_config,
     )
-    content_types = {b.get("type") for b in (user_message.get("content") or []) if isinstance(b, dict)}
-    if "image" in content_types and not model_meta.supports_image_input:
-        raise HTTPException(status_code=400, detail="current model does not support image input")
-    if "document" in content_types and not model_meta.supports_pdf_input:
-        raise HTTPException(status_code=400, detail="current model does not support PDF input")
+    _check_input_support(user_message, model_meta)
 
     reasoning_effort = resolved.reasoning_effort
     if "reasoning_effort" in chat.model_fields_set:
@@ -241,9 +282,10 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep) -> ChatR
             existing_messages = data["messages"] if data else []
             _validate_rewind_request(session=session, messages=existing_messages, rewind_to=chat.rewind_to)
 
-        # All validation passed. Land the rewind marker (if any) and register
-        # the user turn in the catalog: first turn creates the entry and sets
-        # the title, later turns bump updated_at.
+        # All validation passed. Save uploads, land the rewind marker (if any)
+        # and register the user turn in the catalog: first turn creates the
+        # entry and sets the title, later turns bump updated_at.
+        await asyncio.to_thread(_write_uploads, uploads)
         if chat.rewind_to is not None:
             await store.append_rewind(session_id, chat.rewind_to)
         session = await store.record_user_turn(
@@ -274,10 +316,11 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep) -> ChatR
         try:
             run = await runs.start_run(
                 session_id=session_id,
+                cwd=cwd,
                 user_message=user_message,
                 base_messages=agent.messages,
                 agent=agent,
-                session_cost_base=await load_session_cost(store, session_id),
+                session_base=await load_session_totals(store, session_id),
             )
         except ActiveRunError as exc:
             existing = await runs.get_run(exc.run_id)
@@ -339,7 +382,7 @@ async def compact_session(
     body: CompactRequest,
     store: StoreDep,
     runs: RunManagerDep,
-) -> CompactResponse:
+) -> RunResponse:
     """Start a compact run: summarize the session and append one compact marker."""
 
     async with runs.session_operation(session_id):
@@ -372,9 +415,10 @@ async def compact_session(
         try:
             run = await runs.start_compact(
                 session_id=session_id,
+                cwd=cwd,
                 base_messages=agent.messages,
                 agent=agent,
-                session_cost_base=data["session_cost"],
+                session_base=data["totals"],
                 on_complete=store.touch,
             )
         except ActiveRunError as exc:
@@ -384,7 +428,95 @@ async def compact_session(
                 detail["run"] = existing.info()
             raise HTTPException(status_code=409, detail=detail) from exc
 
-    return CompactResponse(run=RunInfo.model_validate(run))
+    return RunResponse(run=RunInfo.model_validate(run))
+
+
+@router.post("/runs/{run_id}/steer")
+async def steer_run(
+    run_id: Annotated[str, PathParam(min_length=1)], body: PendingInputRequest, store: StoreDep, runs: RunManagerDep
+) -> RunResponse:
+    """Hand a user message to the running chat for its next step boundary."""
+
+    state = await runs.get_run(run_id)
+    if state is None:
+        raise HTTPException(status_code=404, detail="run not found")
+    message, uploads = await _build_user_message(
+        body, CliDeps.for_session(cwd=state.cwd, data_dir=store.data_dir, session_id=state.session_id)
+    )
+    message["meta"] = {"input_id": body.input_id}
+    _check_input_support(message, state.agent)
+    # Uploads are on disk before the model can see the message; a refusal removes them.
+    await asyncio.to_thread(_write_uploads, uploads)
+    if not state.agent.steer(message):
+        await asyncio.to_thread(_remove_uploads, uploads)
+        raise HTTPException(
+            status_code=409,
+            detail={"message": "run is not accepting steers", "run": state.info()},
+        )
+    return RunResponse(run=RunInfo.model_validate(state.info()))
+
+
+@router.post("/sessions/{session_id}/queue")
+async def queue_message(
+    session_id: Annotated[str, PathParam(min_length=1)],
+    body: PendingInputRequest,
+    store: StoreDep,
+    runs: RunManagerDep,
+) -> RunResponse:
+    """Queue a user message as the next turn of the session's running chat."""
+
+    state = await runs.get_active_run(session_id)
+    if state is None:
+        raise HTTPException(status_code=409, detail={"message": "session has no running chat to queue on"})
+    message, uploads = await _build_user_message(
+        body, CliDeps.for_session(cwd=state.cwd, data_dir=store.data_dir, session_id=session_id)
+    )
+    message["meta"] = {"input_id": body.input_id}
+    _check_input_support(message, state.agent)
+    await asyncio.to_thread(_write_uploads, uploads)
+    if not await runs.enqueue(state, message):
+        await asyncio.to_thread(_remove_uploads, uploads)
+        raise HTTPException(status_code=409, detail={"message": "session has no running chat to queue on"})
+    await store.record_user_turn(
+        session_id,
+        cwd=state.cwd,
+        text=flatten_message_text(message, include_thinking=False),
+    )
+    return RunResponse(run=RunInfo.model_validate(state.info()))
+
+
+@router.delete("/sessions/{session_id}/queue/{input_id}")
+async def remove_queued_message(
+    session_id: Annotated[str, PathParam(min_length=1)],
+    input_id: Annotated[str, PathParam(min_length=1)],
+    runs: RunManagerDep,
+) -> RunResponse:
+    """Remove a queued message that has not been delivered."""
+
+    run = await runs.remove_queued(session_id, input_id)
+    if run is None:
+        raise HTTPException(status_code=404, detail="queued message not found")
+    return RunResponse(run=RunInfo.model_validate(run))
+
+
+@router.post("/sessions/{session_id}/queue/{input_id}/steer")
+async def steer_queued_message(
+    session_id: Annotated[str, PathParam(min_length=1)],
+    input_id: Annotated[str, PathParam(min_length=1)],
+    runs: RunManagerDep,
+) -> RunResponse:
+    """Move a queued message into the current turn, keeping it as built."""
+
+    state = await runs.get_active_run(session_id)
+    moved = None if state is None else await runs.steer_queued(state, input_id)
+    if state is None or moved is None:
+        raise HTTPException(status_code=404, detail="queued message not found")
+    if not moved:
+        raise HTTPException(
+            status_code=409,
+            detail={"message": "run is not accepting steers", "run": state.info()},
+        )
+    return RunResponse(run=RunInfo.model_validate(state.info()))
 
 
 @router.get("/config")
@@ -454,6 +586,10 @@ async def get_config(cwd: Annotated[str | None, Query()] = None) -> dict[str, An
         "cwd_exists": os.path.isdir(resolved_cwd),
         "project": settings.project,
         "config_paths": settings.config_paths,
+        # Effective for this cwd; 0 disables automatic compaction.
+        "compact_threshold": (
+            settings.compact_threshold if settings.compact_threshold is not None else DEFAULT_COMPACT_THRESHOLD
+        ),
         "skills": [{"name": skill.name, "description": skill.description} for skill in skills],
         "setup_error": setup_error,
     }

mycode_cli/server/routers/sessions.py

@@ -11,6 +11,7 @@ from fastapi import Path as PathParam
 from mycode.messages import ConversationMessage
 from mycode_cli.server.deps import RunManagerDep, StoreDep, resolve_workspace_cwd
 from mycode_cli.server.schemas import SessionCreateRequest, StatusResponse
+from mycode_cli.sessions import SessionTotals
 
 router = APIRouter(prefix="/sessions", tags=["sessions"])
 
@@ -50,6 +51,21 @@ async def list_sessions(
     return {"sessions": sessions}
 
 
+@router.get("/search")
+async def search_sessions(
+    store: StoreDep,
+    runs: RunManagerDep,
+    q: Annotated[str, Query(min_length=1)],
+    cwd: Annotated[str | None, Query()] = None,
+    limit: Annotated[int, Query(ge=1)] = 50,
+) -> dict[str, Any]:
+    results = await store.search_sessions(q, cwd=cwd, limit=limit)
+    for result in results:
+        session = result["session"]
+        session["is_running"] = await runs.has_active_run(str(session["id"]))
+    return {"results": results}
+
+
 @router.get("/{session_id}")
 async def load_session(
     session_id: Annotated[str, PathParam(min_length=1)], store: StoreDep, runs: RunManagerDep
@@ -62,22 +78,31 @@ async def load_session(
             return {
                 "session": await store.load_metadata(session_id),
                 "messages": _redact_document_data(active["messages"]),
-                "session_cost": active["session_cost"],
+                **active["totals"].payload(),
                 "active_run": active["run"],
                 "pending_events": active["pending_events"],
+                "pending": {kind: _redact_document_data(messages) for kind, messages in active["pending"].items()},
             }
 
         data = await store.load_session(session_id)
 
     if data is None:
-        return {"session": None, "messages": [], "session_cost": None, "active_run": None, "pending_events": []}
+        return {
+            "session": None,
+            "messages": [],
+            **SessionTotals().payload(),
+            "active_run": None,
+            "pending_events": [],
+            "pending": {"steers": [], "queue": []},
+        }
 
     return {
         "session": data["session"],
         "messages": _redact_document_data(data["messages"]),
-        "session_cost": data["session_cost"],
+        **data["totals"].payload(),
         "active_run": None,
         "pending_events": [],
+        "pending": {"steers": [], "queue": []},
     }
 
 
@@ -90,14 +115,3 @@ async def delete_session(
             raise HTTPException(status_code=409, detail="session has a running task")
         await store.delete_session(session_id)
     return StatusResponse(status="ok")
-
-
-@router.post("/{session_id}/clear")
-async def clear_session(
-    session_id: Annotated[str, PathParam(min_length=1)], store: StoreDep, runs: RunManagerDep
-) -> StatusResponse:
-    async with runs.session_operation(session_id):
-        if await runs.has_active_run(session_id):
-            raise HTTPException(status_code=409, detail="session has a running task")
-        await store.clear_session(session_id)
-    return StatusResponse(status="ok")