mycode-cli 0.17.0__py3-none-any.whl → 0.18.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/server/routers/chat.py

@@ -30,11 +30,11 @@ from mycode.messages import (
     image_block,
     text_block,
 )
-from mycode.providers import provider_default_models
 from mycode_cli.config import (
     ResolvedProvider,
     get_settings,
     normalize_reasoning_effort,
+    provider_models,
     resolve_configured_model_metadata,
     resolve_provider,
     resolve_provider_choices,
@@ -402,13 +402,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,