mycode-cli 0.17.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

mycode_cli/config.py

@@ -99,8 +99,6 @@ class WebConfig:
 @dataclass(frozen=True)
 class Settings:
     providers: dict[str, ProviderConfig]
-    default_provider: str | None
-    default_model: str | None
     port: int
     cwd: str
     project: str
@@ -305,10 +303,14 @@ def _clean_config_layer(data: Any) -> dict[str, Any]:
 
     out: dict[str, Any] = {}
 
-    if data.get("default") is not None:
-        default = _validate_default_config(data["default"])
-        if default:
-            out["default"] = default
+    compact_threshold = data.get("compact_threshold")
+    if compact_threshold is False:
+        out["compact_threshold"] = False
+    elif compact_threshold is not None:
+        parsed = None if isinstance(compact_threshold, bool) else parse_compact_threshold(compact_threshold)
+        if parsed is None:
+            raise ValueError("compact_threshold must be a number in [0, 1] or false")
+        out["compact_threshold"] = parsed
 
     if data.get("permission") is not None:
         out["permission"] = _validate_permission_config(data["permission"])
@@ -345,30 +347,6 @@ def _optional_config_string(raw: dict[str, Any], key: str, label: str) -> str |
     return value.strip() or None
 
 
-def _validate_default_config(raw: Any) -> dict[str, Any]:
-    if not isinstance(raw, dict):
-        raise ValueError("default must be an object")
-
-    out: dict[str, Any] = {}
-    for key in ("provider", "model"):
-        value = _optional_config_string(raw, key, f"default.{key}")
-        if value:
-            out[key] = value
-
-    compact_threshold = raw.get("compact_threshold")
-    if compact_threshold is False:
-        out["compact_threshold"] = False
-    elif compact_threshold is not None:
-        if isinstance(compact_threshold, bool):
-            raise ValueError("default.compact_threshold must be a number in [0, 1] or false")
-        parsed = parse_compact_threshold(compact_threshold)
-        if parsed is None:
-            raise ValueError("default.compact_threshold must be a number in [0, 1] or false")
-        out["compact_threshold"] = parsed
-
-    return out
-
-
 def _validate_permission_config(raw: Any) -> PermissionLevel | dict[str, Any]:
     if isinstance(raw, str):
         return normalize_permission_level(raw)
@@ -498,8 +476,6 @@ def get_settings(cwd: str | None = None) -> Settings:
     resolved_project = str(resolve_project(resolved_cwd))
 
     raw_providers: dict[str, dict[str, Any]] = {}
-    default_provider: str | None = None
-    default_model: str | None = None
     compact_threshold: float | None = None
     permission = PermissionConfig()
     raw_web: dict[str, Any] = {}
@@ -534,13 +510,8 @@ def get_settings(cwd: str | None = None) -> Settings:
 
             raw_providers[name] = merged
 
-        default = data.get("default", {})
-        if "provider" in default:
-            default_provider = default["provider"]
-        if "model" in default:
-            default_model = default["model"]
-        if "compact_threshold" in default:
-            compact_threshold = float(default["compact_threshold"])
+        if "compact_threshold" in data:
+            compact_threshold = float(data["compact_threshold"])
 
         if "permission" in data:
             permission = parse_permission(data.get("permission"), permission)
@@ -561,8 +532,6 @@ def get_settings(cwd: str | None = None) -> Settings:
 
     return Settings(
         providers=_build_providers(raw_providers),
-        default_provider=default_provider,
-        default_model=default_model,
         compact_threshold=compact_threshold,
         permission=permission,
         web=_build_web_config(raw_web),
@@ -691,44 +660,35 @@ def resolve_provider(
     api_key: str | None = None,
     api_base: str | None = None,
 ) -> ResolvedProvider:
-    """Resolve provider, model, api_key, and api_base from settings and overrides."""
-
-    selected_name = (provider_name or settings.default_provider or "").strip()
-    if selected_name:
-        try:
-            return _resolve_provider_runtime(
-                settings,
-                selected_name=selected_name,
-                model=model,
-                api_key=api_key,
-                api_base=api_base,
+    """Resolve provider, model, api_key, and api_base from settings and overrides.
+
+    Without a provider name, the first available provider is used.
+    """
+
+    selected_name = (provider_name or "").strip()
+    if not selected_name:
+        refs = _available_provider_references(settings)
+        if not refs:
+            env_names = list(
+                dict.fromkeys(
+                    env_name
+                    for provider_id in list_env_discoverable_providers()
+                    for env_name in provider_env_api_key_names(provider_id)
+                )
             )
-        except ValueError:
-            # A caller-supplied provider_name must fail loudly rather than silently fall back.
-            if provider_name:
-                raise
-
-    refs = _available_provider_references(settings)
-    if refs:
-        return _resolve_provider_runtime(
-            settings,
-            selected_name=refs[0],
-            model=model,
-            api_key=api_key,
-            api_base=api_base,
-        )
+            checked = ", ".join(env_names) or "<api key env>"
+            raise ValueError(
+                "no available providers found; set one of the supported API key env vars "
+                + f"({checked}) or configure a provider in ~/.mycode/config.json or a project .mycode/config.json"
+            )
+        selected_name = refs[0]
 
-    env_names = list(
-        dict.fromkeys(
-            env_name
-            for provider_id in list_env_discoverable_providers()
-            for env_name in provider_env_api_key_names(provider_id)
-        )
-    )
-    checked = ", ".join(env_names) or "<api key env>"
-    raise ValueError(
-        "no available providers found; set one of the supported API key env vars "
-        + f"({checked}) or configure a provider in ~/.mycode/config.json or a project .mycode/config.json"
+    return _resolve_provider_runtime(
+        settings,
+        selected_name=selected_name,
+        model=model,
+        api_key=api_key,
+        api_base=api_base,
     )
 
 
@@ -744,41 +704,32 @@ def resolve_provider_choices(settings: Settings) -> list[ResolvedProvider]:
     return choices
 
 
-def _available_provider_references(settings: Settings) -> list[str]:
-    """Return usable provider names with the configured default first."""
-
-    available: list[str] = []
-    seen: set[str] = set()
-    configured_types_with_credentials: set[str] = set()
+def provider_models(settings: Settings, provider: ResolvedProvider) -> list[str]:
+    """Return a resolved provider's selectable models: configured ones, else the adapter defaults."""
 
-    def add(name: str | None) -> None:
-        cleaned = (name or "").strip()
-        if not cleaned or cleaned in seen:
-            return
+    provider_config = settings.providers.get(provider.provider_name or "")
+    if provider_config and provider_config.models:
+        return list(provider_config.models)
+    return list(provider_default_models(provider.provider)) or [provider.model]
 
-        provider_config = settings.providers.get(cleaned)
-        provider_type = provider_config.type if provider_config else cleaned
-        if not is_supported_provider(provider_type):
-            return
 
-        if provider_config:
-            if not provider_is_available(provider_config):
-                return
-            configured_types_with_credentials.add(provider_type)
-        elif not provider_api_key_from_env(provider_type):
-            return
-
-        seen.add(cleaned)
-        available.append(cleaned)
-
-    add(settings.default_provider)
+def _available_provider_references(settings: Settings) -> list[str]:
+    """Return usable provider names: configured providers in order, then env-discovered built-ins."""
 
-    for name in settings.providers:
-        add(name)
+    available: list[str] = []
+    configured_types: set[str] = set()
+    for name, config in settings.providers.items():
+        if is_supported_provider(config.type) and provider_is_available(config):
+            available.append(name)
+            configured_types.add(config.type)
 
     for provider_id in list_env_discoverable_providers():
-        if provider_id not in configured_types_with_credentials:
-            add(provider_id)
+        if (
+            provider_id not in configured_types
+            and provider_id not in settings.providers
+            and provider_api_key_from_env(provider_id)
+        ):
+            available.append(provider_id)
 
     return available
 
@@ -805,8 +756,6 @@ def _resolve_provider_runtime(
         resolved_model = requested_model
     elif provider_config and provider_config.models:
         resolved_model = next(iter(provider_config.models))
-    elif selected_name == settings.default_provider and (settings.default_model or "").strip():
-        resolved_model = str(settings.default_model).strip()
     else:
         defaults = provider_default_models(provider_type)
         if not defaults:

mycode_cli/main.py

@@ -5,9 +5,9 @@ from __future__ import annotations
 import asyncio
 import os
 import sys
-from contextlib import aclosing, suppress
+from contextlib import aclosing
 from dataclasses import dataclass, replace
-from typing import TYPE_CHECKING, Annotated, Any, Literal
+from typing import Annotated, Any, Literal
 from uuid import uuid4
 
 import typer
@@ -21,17 +21,14 @@ from mycode_cli.config import (
     get_settings,
     normalize_reasoning_effort,
     parse_permission,
-    resolve_provider,
     resolve_sessions_dir,
 )
 from mycode_cli.permissions import PERMISSION_DENIED_BY_USER_OUTPUT, PERMISSION_DENIED_OUTPUT
 from mycode_cli.sessions import SessionStore
+from mycode_cli.state import load_state, resolve_remembered_provider
 
 from .runtime import build_agent
 
-if TYPE_CHECKING:
-    from .tui.render import TerminalView
-
 app = typer.Typer(add_completion=False, pretty_exceptions_enable=False)
 session_app = typer.Typer(help="Session management")
 app.add_typer(session_app, name="session")
@@ -140,7 +137,6 @@ async def run_noninteractive(agent: Agent, message: str, *, store: SessionStore,
 @dataclass
 class _BootstrapContext:
     store: SessionStore
-    view: TerminalView
     settings: Settings
     resolved_provider: ResolvedProvider
     resolved_session: ResolvedSession
@@ -159,21 +155,20 @@ def _bootstrap(
 ) -> _BootstrapContext:
     """Shared setup for the chat and run commands."""
 
-    from .tui.render import TerminalView
-
     if session and continue_last:
         raise typer.BadParameter("--session and --continue are mutually exclusive")
 
     cwd = os.path.abspath(os.getcwd())
     store = SessionStore(data_dir=resolve_sessions_dir())
-    view = TerminalView()
     try:
         settings = get_settings(cwd)
         if permission is not None:
             settings = replace(settings, permission=parse_permission(permission, settings.permission))
-        resolved_provider = resolve_provider(settings, provider_name=provider, model=model)
-        resolved_effort = normalize_reasoning_effort(reasoning_effort)
-        if resolved_effort is not None:
+        state = load_state()
+        resolved_provider = resolve_remembered_provider(settings, state, provider_name=provider, model=model)
+        if reasoning_effort is None:
+            resolved_effort = state.effort_for(resolved_provider)
+        elif (resolved_effort := normalize_reasoning_effort(reasoning_effort)) is not None:
             if not resolved_provider.supports_reasoning_effort:
                 raise ValueError(f"provider {resolved_provider.provider!r} does not support reasoning effort")
             if resolved_effort not in resolved_provider.reasoning_efforts:
@@ -182,6 +177,7 @@ def _bootstrap(
                     f"reasoning effort {resolved_effort!r} is not supported by model {resolved_provider.model!r}; "
                     + f"supported efforts: {supported}"
                 )
+        resolved_provider = replace(resolved_provider, reasoning_effort=resolved_effort)
         resolved_session = asyncio.run(
             resolve_session(
                 store=store,
@@ -191,7 +187,9 @@ def _bootstrap(
             )
         )
     except ValueError as exc:
-        view.console.print(f"[red]{exc}[/red]")
+        from .tui.render import console, error_line
+
+        console.print(error_line(str(exc)))
         raise SystemExit(1) from exc
 
     agent = build_agent(
@@ -202,12 +200,9 @@ def _bootstrap(
         session_id=resolved_session.session_id,
         max_turns=max_turns,
     )
-    if reasoning_effort is not None:
-        agent.reasoning_effort = resolved_effort
 
     return _BootstrapContext(
         store=store,
-        view=view,
         settings=settings,
         resolved_provider=resolved_provider,
         resolved_session=resolved_session,
@@ -266,22 +261,11 @@ def chat(
         session_id=setup.resolved_session.session_id,
         provider_name=setup.resolved_provider.provider_name,
         reasoning_efforts=setup.resolved_provider.reasoning_efforts,
-        view=setup.view,
-    )
-
-    setup.view.print_header(
-        provider=setup.resolved_provider.provider,
-        model=setup.resolved_provider.model,
         session=setup.resolved_session.session,
         mode=setup.resolved_session.mode,
-        message_count=len(setup.resolved_session.messages),
-        reasoning_effort=setup.agent.reasoning_effort,
+        messages=setup.resolved_session.messages,
     )
-    if setup.resolved_session.mode == "resumed":
-        setup.view.print_history_preview(setup.resolved_session.messages)
-
-    with suppress(KeyboardInterrupt):
-        asyncio.run(terminal_chat.run())
+    asyncio.run(terminal_chat.run())
 
 
 @app.command()
@@ -355,15 +339,15 @@ def session_list(
 ) -> None:
     """List saved sessions."""
 
-    from .tui.render import TerminalView
+    from .tui.render import console, session_list_table
 
     cwd = os.path.abspath(os.getcwd())
     store = SessionStore(data_dir=resolve_sessions_dir())
-    view = TerminalView()
 
     sessions = asyncio.run(store.list_sessions(cwd=None if all_workspaces else cwd))
     heading = "all sessions" if all_workspaces else f"sessions for {cwd}"
-    view.print_session_list(sessions, include_cwd=all_workspaces, heading=heading)
+    for renderable in session_list_table(sessions, include_cwd=all_workspaces, heading=heading):
+        console.print(renderable)
 
 
 def main() -> None:

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

@@ -21,7 +21,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,29 +30,32 @@ from mycode.messages import (
     image_block,
     text_block,
 )
-from mycode.providers import provider_default_models
+from mycode.models import ModelMetadata
 from mycode_cli.config import (
     ResolvedProvider,
     get_settings,
     normalize_reasoning_effort,
+    provider_models,
     resolve_configured_model_metadata,
     resolve_provider,
     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
@@ -86,7 +89,7 @@ def _read_workspace_text_attachment(rel_path: str, *, name: str | None, cwd: str
         raise HTTPException(status_code=400, detail=str(exc)) from exc
 
 
-async def _build_user_message(chat: ChatRequest, cwd: str) -> ConversationMessage:
+async def _build_user_message(chat: UserInputRequest, cwd: str) -> ConversationMessage:
     if not chat.input:
         text = str(chat.message or "").strip()
         snapshots = await asyncio.to_thread(build_skill_snapshot_blocks, text, cwd)
@@ -143,6 +146,14 @@ async def _build_user_message(chat: ChatRequest, cwd: str) -> ConversationMessag
     return build_message("user", blocks)
 
 
+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(
     *,
     session: dict[str, Any] | None,
@@ -192,11 +203,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:
@@ -274,10 +281,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 +347,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 +380,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 +393,86 @@ 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, 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 = await _build_user_message(body, state.cwd)
+    message["meta"] = {"input_id": body.input_id}
+    _check_input_support(message, state.agent)
+    if not state.agent.steer(message):
+        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 = await _build_user_message(body, state.cwd)
+    message["meta"] = {"input_id": body.input_id}
+    _check_input_support(message, state.agent)
+    if not await runs.enqueue(state, message):
+        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")
@@ -402,13 +490,7 @@ async def get_config(cwd: Annotated[str | None, Query()] = None) -> dict[str, An
     providers_info: dict[str, Any] = {}
     for provider in resolve_provider_choices(settings):
         provider_config = settings.providers.get(provider.provider_name or "")
-        models = (
-            list(provider_config.models)
-            if provider_config and provider_config.models
-            else list(provider_default_models(provider.provider))
-        )
-        if not models:
-            models = [provider.model]
+        models = provider_models(settings, provider)
 
         info: dict[str, Any] = {
             "name": provider.provider_name,
@@ -460,6 +542,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,
     }