mycode-cli 0.8.2__py3-none-any.whl → 0.8.4__py3-none-any.whl

mycode_cli/config.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import json
-import logging
 import os
 import re
 from dataclasses import dataclass, field
@@ -60,15 +59,6 @@ class ModelConfig:
     supports_pdf_input: bool | None = None
 
 
-_MODEL_OVERRIDE_KEYS = (
-    "context_window",
-    "max_output_tokens",
-    "supports_reasoning",
-    "supports_image_input",
-    "supports_pdf_input",
-)
-
-
 @dataclass(frozen=True)
 class ProviderConfig:
     name: str
@@ -110,6 +100,7 @@ class ResolvedProvider:
     api_base: str | None
     reasoning_effort: str | None
     provider_name: str | None = None
+    model_config: ModelConfig | None = None
 
 
 def _load_json(path: Path) -> dict[str, Any] | None:
@@ -571,170 +562,5 @@ def _resolve_provider_runtime(
         api_key=resolved_api_key,
         api_base=resolved_api_base,
         reasoning_effort=reasoning_effort,
+        model_config=model_config,
     )
-
-
-def is_api_key_env_ref(value: str) -> str | None:
-    """Return the env var name when ``value`` is a ``${NAME}`` reference."""
-
-    match = _API_KEY_ENV_REF_RE.fullmatch(value.strip())
-    return match.group(1) if match else None
-
-
-def _optional_string(raw: dict[str, Any], key: str, label: str) -> str | None:
-    """Read an optional string field. Returns the trimmed value, or ``None`` when
-    absent / null / empty so callers can simply skip the key."""
-
-    if key not in raw:
-        return None
-    value = raw[key]
-    if value is None or value == "":
-        return None
-    if not isinstance(value, str):
-        raise ValueError(f"{label} must be a string")
-    return value.strip() or None
-
-
-def _validate_default(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_string(raw, key, f"default.{key}")
-        if value:
-            out[key] = value
-
-    effort = raw.get("reasoning_effort")
-    if effort not in (None, ""):
-        normalize_reasoning_effort(effort)
-        out["reasoning_effort"] = effort
-
-    ct = raw.get("compact_threshold")
-    if ct is False:
-        out["compact_threshold"] = False
-    elif ct is not None:
-        if isinstance(ct, bool) or not isinstance(ct, int | float) or not 0 <= ct <= 1:
-            raise ValueError("default.compact_threshold must be a number in [0, 1] or false")
-        out["compact_threshold"] = float(ct)
-
-    return out
-
-
-def _validate_permission(raw: Any) -> Any:
-    if isinstance(raw, str):
-        return normalize_permission_level(raw)
-    if not isinstance(raw, dict):
-        raise ValueError("permission must be a string or object")
-
-    out: dict[str, Any] = {}
-    if "level" in raw:
-        out["level"] = normalize_permission_level(raw.get("level"))
-    if "mode" in raw:
-        out["mode"] = normalize_permission_mode(raw.get("mode"))
-    return out
-
-
-def _validate_provider(name: str, raw: Any) -> dict[str, Any]:
-    if not isinstance(raw, dict):
-        raise ValueError(f"provider {name!r} must be an object")
-
-    out: dict[str, Any] = {}
-
-    raw_type = raw.get("type")
-    if raw_type in (None, ""):
-        # Built-in name → type fallback; otherwise the user must spell it out.
-        if not is_supported_provider(name):
-            raise ValueError(f"provider {name!r} must set 'type'")
-    elif not isinstance(raw_type, str):
-        raise ValueError(f"provider {name!r}: type must be a string")
-    elif not is_supported_provider(raw_type):
-        supported = ", ".join(list_supported_providers())
-        raise ValueError(f"provider {name!r}: unsupported type {raw_type!r}; supported: {supported}")
-    else:
-        out["type"] = raw_type
-
-    for key in ("api_key", "base_url"):
-        value = _optional_string(raw, key, f"provider {name!r}: {key}")
-        if value:
-            out[key] = value
-
-    effort = raw.get("reasoning_effort")
-    if effort not in (None, ""):
-        normalize_reasoning_effort(effort)
-        out["reasoning_effort"] = effort
-
-    raw_models = raw.get("models")
-    if raw_models is not None:
-        models = _validate_models(name, raw_models)
-        if models:
-            out["models"] = models
-
-    return out
-
-
-def _validate_models(name: str, raw: Any) -> dict[str, dict[str, Any]]:
-    # Both list (ids only) and dict (id → metadata overrides) are accepted; we
-    # always normalise to the dict form for storage.
-    if isinstance(raw, list):
-        items: list[tuple[Any, Any]] = [(m, None) for m in raw]
-    elif isinstance(raw, dict):
-        items = list(raw.items())
-    else:
-        raise ValueError(f"provider {name!r}: models must be a list or object")
-
-    out: dict[str, dict[str, Any]] = {}
-    for model_id, overrides in items:
-        if not isinstance(model_id, str) or not model_id.strip():
-            raise ValueError(f"provider {name!r}: model id must be a non-empty string")
-        key = model_id.strip()
-        if overrides is None:
-            out[key] = {}
-        elif isinstance(overrides, dict):
-            out[key] = {k: v for k, v in overrides.items() if k in _MODEL_OVERRIDE_KEYS and v is not None}
-        else:
-            raise ValueError(f"provider {name!r}: model {key!r} config must be an object")
-    return out
-
-
-def validate_global_config(data: Any) -> dict[str, Any]:
-    """Validate a raw global config payload. Returns a cleaned dict ready to persist.
-
-    Empty / null fields are dropped. Raises ``ValueError`` on invalid input.
-    """
-
-    if data is None:
-        return {}
-    if not isinstance(data, dict):
-        raise ValueError("config must be an object")
-
-    out: dict[str, Any] = {}
-
-    if data.get("default") is not None:
-        default = _validate_default(data["default"])
-        if default:
-            out["default"] = default
-
-    if data.get("permission") is not None:
-        out["permission"] = _validate_permission(data["permission"])
-
-    raw_providers = data.get("providers")
-    if raw_providers is not None:
-        if not isinstance(raw_providers, dict):
-            raise ValueError("providers must be an object")
-        providers: dict[str, dict[str, Any]] = {}
-        for name, raw in raw_providers.items():
-            if not isinstance(name, str) or not name.strip():
-                raise ValueError("provider name must be a non-empty string")
-            cleaned = name.strip()
-            providers[cleaned] = _validate_provider(cleaned, raw)
-        if providers:
-            out["providers"] = providers
-
-    return out
-
-
-def setup_logging() -> None:
-    """Configure default logging."""
-
-    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")

mycode_cli/main.py

@@ -6,7 +6,8 @@ import asyncio
 import os
 import sys
 from dataclasses import dataclass, replace
-from typing import Annotated
+from typing import Annotated, Any
+from uuid import uuid4
 
 import typer
 
@@ -24,7 +25,7 @@ from mycode_cli.config import (
 )
 from mycode_cli.permissions import PERMISSION_DENIED_BY_USER_OUTPUT, PERMISSION_DENIED_OUTPUT
 
-from .runtime import ResolvedSession, build_agent, resolve_session
+from .runtime import build_agent
 from .tui.chat import TerminalChat
 from .tui.render import TerminalView
 
@@ -33,6 +34,58 @@ session_app = typer.Typer(help="Session management")
 app.add_typer(session_app, name="session")
 
 
+@dataclass
+class ResolvedSession:
+    """The session selected for the current CLI run.
+
+    `mode` is either `"new"` or `"resumed"`.
+    """
+
+    session_id: str
+    session: dict[str, Any]
+    messages: list[dict[str, Any]]
+    mode: str
+
+
+async def resolve_session(
+    *,
+    store: SessionStore,
+    cwd: str,
+    requested_session_id: str | None,
+    continue_last: bool,
+) -> ResolvedSession:
+    """Resolve which session the CLI should load before starting."""
+
+    if requested_session_id:
+        data = await store.load_session(requested_session_id)
+        if not data or not data.get("session"):
+            raise ValueError(f"Unknown session: {requested_session_id}")
+        return ResolvedSession(
+            requested_session_id,
+            data.get("session") or {},
+            data.get("messages") or [],
+            "resumed",
+        )
+
+    if continue_last:
+        latest = await store.latest_session(cwd=cwd)
+        if latest and latest.get("id"):
+            session_id = str(latest["id"])
+            data = await store.load_session(session_id)
+            if not data:
+                raise ValueError(f"Unknown session: {session_id}")
+            return ResolvedSession(
+                session_id,
+                data.get("session") or latest,
+                data.get("messages") or [],
+                "resumed",
+            )
+
+    # New sessions: the id is allocated here; the on-disk session is created
+    # lazily by Agent.achat on the first persist.
+    return ResolvedSession(uuid4().hex, {}, [], "new")
+
+
 def _show_version(value: bool) -> None:
     if not value:
         return

mycode_cli/runtime.py

@@ -1,48 +1,15 @@
-"""CLI session selection and runtime updates."""
+"""Build an Agent from CLI settings — shared by both the TUI and the web server."""
 
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import Any
-from uuid import uuid4
-
 from mycode.agent import Agent
-from mycode.providers import (
-    get_provider_adapter,
-    list_env_discoverable_providers,
-    provider_api_key_from_env,
-    provider_default_models,
-)
 from mycode.session import SessionStore
 from mycode.tools import DEFAULT_TOOL_SPECS
-from mycode_cli.config import ResolvedProvider, Settings, provider_has_api_key
+from mycode_cli.config import ResolvedProvider, Settings
 from mycode_cli.permissions import ToolReviewCallback, build_permission_hooks
 from mycode_cli.system_prompt import build_system_prompt
 
 
-@dataclass
-class ResolvedSession:
-    """The session selected for the current CLI run.
-
-    `mode` is either `"new"` or `"resumed"`.
-    """
-
-    session_id: str
-    session: dict[str, Any]
-    messages: list[dict[str, Any]]
-    mode: str
-
-
-@dataclass(frozen=True)
-class ProviderOption:
-    """A provider option shown in the interactive provider switcher."""
-
-    name: str
-    provider: str
-    models: tuple[str, ...]
-    api_base: str | None
-
-
 def build_agent(
     *,
     store: SessionStore,
@@ -60,8 +27,7 @@ def build_agent(
     the store; callers never pass messages explicitly.
     """
 
-    provider_config = settings.providers.get(resolved_provider.provider_name or "")
-    model_config = provider_config.models.get(resolved_provider.model) if provider_config else None
+    model_config = resolved_provider.model_config
     agent = Agent(
         model=resolved_provider.model,
         provider=resolved_provider.provider,
@@ -83,162 +49,3 @@ def build_agent(
     )
     agent.hooks = build_permission_hooks(settings, review=review, on_user_denied=agent.cancel)
     return agent
-
-
-def clone_agent(agent: Agent, *, store: SessionStore, session_id: str) -> Agent:
-    """Keep the current runtime config while swapping session state.
-
-    History auto-loads from disk when ``session_id`` exists under the store.
-    """
-
-    return Agent(
-        model=agent.model,
-        provider=agent.provider,
-        cwd=agent.cwd,
-        session_dir=store.data_dir,
-        session_id=session_id,
-        api_key=agent.api_key,
-        api_base=agent.api_base,
-        max_turns=agent.max_turns,
-        max_tokens=agent.max_tokens,
-        context_window=agent.context_window,
-        compact_threshold=agent.compact_threshold,
-        reasoning_effort=agent.reasoning_effort,
-        supports_reasoning=agent.supports_reasoning,
-        supports_image_input=agent.supports_image_input,
-        supports_pdf_input=agent.supports_pdf_input,
-        system=agent.system,
-        tools=DEFAULT_TOOL_SPECS,
-        hooks=agent.hooks,
-    )
-
-
-def list_provider_options(settings: Settings) -> list[ProviderOption]:
-    """Return configured providers plus env-discovered built-ins."""
-
-    options: list[ProviderOption] = []
-    configured_types: set[str] = set()
-
-    for name, config in settings.providers.items():
-        models = tuple(config.models)
-        options.append(
-            ProviderOption(
-                name=name,
-                provider=config.type,
-                models=models,
-                api_base=config.base_url,
-            )
-        )
-        if provider_has_api_key(config):
-            configured_types.add(config.type)
-
-    for provider_name in list_env_discoverable_providers():
-        if provider_name in configured_types or not provider_api_key_from_env(provider_name):
-            continue
-        options.append(
-            ProviderOption(
-                name=provider_name,
-                provider=provider_name,
-                models=provider_default_models(provider_name),
-                api_base=None,
-            )
-        )
-
-    return options
-
-
-def get_provider_option(settings: Settings, *, provider: str, api_base: str | None) -> ProviderOption | None:
-    """Return the current selectable provider option."""
-
-    for option in list_provider_options(settings):
-        if option.provider == provider and option.api_base == api_base:
-            return option
-    return None
-
-
-def list_model_options(settings: Settings, *, provider: str, api_base: str | None, current_model: str) -> list[str]:
-    """Return the selectable model list for the current provider runtime."""
-
-    option = get_provider_option(settings, provider=provider, api_base=api_base)
-    models = option.models if option else provider_default_models(provider)
-    return list(dict.fromkeys([current_model, *models]))
-
-
-def supports_reasoning_effort(agent: Agent) -> bool:
-    """Return whether the current agent provider+model supports reasoning effort."""
-
-    return agent.supports_reasoning is True and get_provider_adapter(agent.provider).supports_reasoning_effort
-
-
-async def resolve_session(
-    *,
-    store: SessionStore,
-    cwd: str,
-    requested_session_id: str | None,
-    continue_last: bool,
-) -> ResolvedSession:
-    """Resolve which session the CLI should load before starting."""
-
-    if requested_session_id:
-        data = await store.load_session(requested_session_id)
-        if not data or not data.get("session"):
-            raise ValueError(f"Unknown session: {requested_session_id}")
-        return ResolvedSession(
-            requested_session_id,
-            data.get("session") or {},
-            data.get("messages") or [],
-            "resumed",
-        )
-
-    if continue_last:
-        latest = await store.latest_session(cwd=cwd)
-        if latest and latest.get("id"):
-            session_id = str(latest["id"])
-            data = await store.load_session(session_id)
-            if not data:
-                raise ValueError(f"Unknown session: {session_id}")
-            return ResolvedSession(
-                session_id,
-                data.get("session") or latest,
-                data.get("messages") or [],
-                "resumed",
-            )
-
-    # New sessions: the id is allocated here; the on-disk session is created
-    # lazily by Agent.achat on the first persist.
-    return ResolvedSession(uuid4().hex, {}, [], "new")
-
-
-def apply_resolved_provider(agent: Agent, resolved: ResolvedProvider, settings: Settings) -> bool:
-    """Copy runtime settings from a resolved provider onto an active agent.
-
-    Returns whether any field actually changed. Does not touch session state.
-    Re-derives model capability fields from metadata when the provider or model
-    changes so the agent reports accurate support flags.
-    """
-
-    runtime_changed = (
-        agent.provider != resolved.provider
-        or agent.model != resolved.model
-        or agent.api_base != resolved.api_base
-        or agent.api_key != resolved.api_key
-        or agent.reasoning_effort != resolved.reasoning_effort
-    )
-
-    agent.provider = resolved.provider
-    agent.model = resolved.model
-    agent.api_key = resolved.api_key
-    agent.api_base = resolved.api_base
-    agent.reasoning_effort = resolved.reasoning_effort
-
-    if runtime_changed:
-        provider_config = settings.providers.get(resolved.provider_name or "")
-        model_config = provider_config.models.get(resolved.model) if provider_config else None
-        agent.refresh_capabilities(
-            max_tokens=model_config.max_output_tokens if model_config else None,
-            context_window=model_config.context_window if model_config else None,
-            supports_reasoning=model_config.supports_reasoning if model_config else None,
-            supports_image_input=model_config.supports_image_input if model_config else None,
-            supports_pdf_input=model_config.supports_pdf_input if model_config else None,
-        )
-    return runtime_changed

mycode_cli/server/app.py

@@ -7,13 +7,10 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 
-from mycode_cli.config import setup_logging
-from mycode_cli.server.routers import (
-    chat_router,
-    sessions_router,
-    settings_router,
-    workspaces_router,
-)
+from mycode_cli.server.routers.chat import router as chat_router
+from mycode_cli.server.routers.sessions import router as sessions_router
+from mycode_cli.server.routers.settings import router as settings_router
+from mycode_cli.server.routers.workspaces import router as workspaces_router
 
 logger = logging.getLogger(__name__)
 
@@ -26,7 +23,7 @@ def web_static_path() -> Path:
 
 def create_app(*, serve_web: bool = True) -> FastAPI:
     """Create the FastAPI app."""
-    setup_logging()
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
     application = FastAPI(title="mycode")
 
     application.add_middleware(

mycode_cli/server/routers/__init__.py

@@ -1,8 +0,0 @@
-"""API routers package."""
-
-from mycode_cli.server.routers.chat import router as chat_router
-from mycode_cli.server.routers.sessions import router as sessions_router
-from mycode_cli.server.routers.settings import router as settings_router
-from mycode_cli.server.routers.workspaces import router as workspaces_router
-
-__all__ = ["chat_router", "sessions_router", "settings_router", "workspaces_router"]

mycode_cli/server/routers/chat.py

@@ -95,7 +95,12 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep):
     if chat.message and chat.input:
         raise HTTPException(status_code=400, detail="message and input are mutually exclusive")
 
-    if chat.input:
+    if not chat.input:
+        message_text = str(chat.message or "").strip()
+        if not message_text:
+            raise HTTPException(status_code=400, detail="message or input is required")
+        user_message = build_message("user", [text_block(message_text)])
+    else:
         blocks: list[dict[str, Any]] = []
         for block in chat.input:
             if block.type == "text":
@@ -110,59 +115,45 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep):
                     )
                 elif text:
                     blocks.append(text_block(text))
-                continue
 
-            if block.type == "document":
+            elif block.type == "document":
                 if block.data:
                     mime_type = block.mime_type or "application/pdf"
                     if mime_type != "application/pdf":
                         raise HTTPException(status_code=400, detail="unsupported document mime_type")
                     blocks.append(document_block(block.data, mime_type=mime_type, name=block.name or "document.pdf"))
-                    continue
-
-                if not block.path:
-                    raise HTTPException(status_code=400, detail="document input requires path or data")
-                document_path = Path(resolve_path(block.path, cwd=cwd))
-                if not document_path.is_file():
-                    raise HTTPException(status_code=400, detail=f"document file not found: {block.path}")
-                mime_type = block.mime_type or detect_document_mime_type(document_path)
-                if mime_type != "application/pdf":
-                    raise HTTPException(status_code=400, detail=f"unsupported document file: {block.path}")
-                document_data = b64encode(document_path.read_bytes()).decode("utf-8")
-                blocks.append(
-                    document_block(
-                        document_data,
-                        mime_type=mime_type,
-                        name=block.name or document_path.name,
-                    )
-                )
-                continue
-
-            if block.data:
-                if not block.mime_type:
-                    raise HTTPException(status_code=400, detail="image data requires mime_type")
-                blocks.append(image_block(block.data, mime_type=block.mime_type, name=block.name or "image"))
-                continue
+                else:
+                    if not block.path:
+                        raise HTTPException(status_code=400, detail="document input requires path or data")
+                    path = Path(resolve_path(block.path, cwd=cwd))
+                    if not path.is_file():
+                        raise HTTPException(status_code=400, detail=f"document file not found: {block.path}")
+                    mime_type = block.mime_type or detect_document_mime_type(path)
+                    if mime_type != "application/pdf":
+                        raise HTTPException(status_code=400, detail=f"unsupported document file: {block.path}")
+                    data = b64encode(path.read_bytes()).decode("utf-8")
+                    blocks.append(document_block(data, mime_type=mime_type, name=block.name or path.name))
 
-            if not block.path:
-                raise HTTPException(status_code=400, detail="image input requires path or data")
-            image_path = Path(resolve_path(block.path, cwd=cwd))
-            if not image_path.is_file():
-                raise HTTPException(status_code=400, detail=f"image file not found: {block.path}")
-            mime_type = block.mime_type or detect_image_mime_type(image_path)
-            if not mime_type:
-                raise HTTPException(status_code=400, detail=f"unsupported image file: {block.path}")
-            image_data = b64encode(image_path.read_bytes()).decode("utf-8")
-            blocks.append(image_block(image_data, mime_type=mime_type, name=block.name or image_path.name))
+            else:  # image
+                if block.data:
+                    if not block.mime_type:
+                        raise HTTPException(status_code=400, detail="image data requires mime_type")
+                    blocks.append(image_block(block.data, mime_type=block.mime_type, name=block.name or "image"))
+                else:
+                    if not block.path:
+                        raise HTTPException(status_code=400, detail="image input requires path or data")
+                    path = Path(resolve_path(block.path, cwd=cwd))
+                    if not path.is_file():
+                        raise HTTPException(status_code=400, detail=f"image file not found: {block.path}")
+                    mime_type = block.mime_type or detect_image_mime_type(path)
+                    if not mime_type:
+                        raise HTTPException(status_code=400, detail=f"unsupported image file: {block.path}")
+                    data = b64encode(path.read_bytes()).decode("utf-8")
+                    blocks.append(image_block(data, mime_type=mime_type, name=block.name or path.name))
 
         if not blocks:
             raise HTTPException(status_code=400, detail="input must include at least one non-empty block")
         user_message = build_message("user", blocks)
-    else:
-        message_text = str(chat.message or "").strip()
-        if not message_text:
-            raise HTTPException(status_code=400, detail="message or input is required")
-        user_message = build_message("user", [text_block(message_text)])
 
     data = await store.load_session(session_id)
     session = (data or {}).get("session")
@@ -197,8 +188,7 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep):
 
     # Capability check before any disk mutation — a failed check must not
     # leave an empty session on disk or land a premature rewind marker.
-    provider_config = settings.providers.get(resolved.provider_name or "")
-    model_config = provider_config.models.get(resolved.model) if provider_config else None
+    model_config = resolved.model_config
     model_meta = resolve_model_metadata(
         provider=resolved.provider,
         model=resolved.model,