mycode-cli 0.14.2__py3-none-any.whl → 0.16.0__py3-none-any.whl

mycode_cli/config.py

@@ -71,6 +71,9 @@ class ProviderConfig:
     # Opt-in for generic openai_chat endpoints that accept the standard
     # top-level reasoning_effort param. Ignored for other provider types.
     supports_reasoning_effort: bool = False
+    # Opt-in for generic openai_chat endpoints that only implement the legacy
+    # max_tokens field. Ignored for other provider types.
+    legacy_max_tokens: bool = False
 
 
 @dataclass(frozen=True)
@@ -119,6 +122,7 @@ class ResolvedProvider:
     provider_name: str | None = None
     model_config: ModelConfig | None = None
     supports_reasoning_effort: bool = False
+    legacy_max_tokens: bool = False
     reasoning_efforts: tuple[str, ...] = ()
 
 
@@ -187,7 +191,7 @@ def parse_compact_threshold(value: Any) -> float | None:
         return None
     threshold = float(value)
 
-    if threshold < 0 or threshold > 1:
+    if not 0 <= threshold <= 1:
         return None
     return threshold
 
@@ -434,6 +438,12 @@ def _validate_provider_config(name: str, raw: Any) -> dict[str, Any]:
             raise ValueError(f"provider {name!r}: supports_reasoning_effort must be a boolean")
         out["supports_reasoning_effort"] = supports_effort
 
+    legacy_max_tokens = raw.get("legacy_max_tokens")
+    if legacy_max_tokens is not None:
+        if not isinstance(legacy_max_tokens, bool):
+            raise ValueError(f"provider {name!r}: legacy_max_tokens must be a boolean")
+        out["legacy_max_tokens"] = legacy_max_tokens
+
     raw_models = raw.get("models")
     if raw_models is not None:
         models = _validate_model_config_entries(name, raw_models)
@@ -504,45 +514,39 @@ def get_settings(cwd: str | None = None) -> Settings:
         if resolved_path not in config_paths:
             config_paths.append(resolved_path)
 
-        for name, raw in (data.get("providers") or {}).items():
-            if not isinstance(name, str) or not isinstance(raw, dict):
-                continue
-
+        for name, raw in data.get("providers", {}).items():
             merged = dict(raw_providers.get(name, {}))
 
             if "type" in raw:
-                merged["type"] = raw.get("type") or "anthropic"
+                merged["type"] = raw["type"]
             if "models" in raw:
-                merged["models"] = raw.get("models")
+                merged["models"] = raw["models"]
             if "api_key" in raw:
-                api_key, api_key_env_var = _parse_config_api_key(raw.get("api_key"))
+                api_key, api_key_env_var = _parse_config_api_key(raw["api_key"])
                 merged["api_key"] = api_key
                 merged["api_key_env_var"] = api_key_env_var
             if "base_url" in raw:
-                merged["base_url"] = raw.get("base_url") or None
+                merged["base_url"] = raw["base_url"]
             if "supports_reasoning_effort" in raw:
-                merged["supports_reasoning_effort"] = raw.get("supports_reasoning_effort")
+                merged["supports_reasoning_effort"] = raw["supports_reasoning_effort"]
+            if "legacy_max_tokens" in raw:
+                merged["legacy_max_tokens"] = raw["legacy_max_tokens"]
 
             raw_providers[name] = merged
 
-        default = data.get("default")
-        if isinstance(default, dict):
-            if "provider" in default:
-                v = default.get("provider")
-                default_provider = v if isinstance(v, str) else None
-            if "model" in default:
-                v = default.get("model")
-                default_model = v if isinstance(v, str) else None
-            if "compact_threshold" in default:
-                parsed_threshold = parse_compact_threshold(default.get("compact_threshold"))
-                if parsed_threshold is not None:
-                    compact_threshold = parsed_threshold
+        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 "permission" in data:
             permission = parse_permission(data.get("permission"), permission)
 
-        if data.get("web") is not None:
-            web = _validate_web_config(data["web"])
+        if "web" in data:
+            web = data["web"]
             for key in ("fetch", "search"):
                 if key in web:
                     raw_web[key] = web[key]
@@ -631,6 +635,7 @@ def _build_providers(raw_providers: dict[str, dict[str, Any]]) -> dict[str, Prov
             api_key_env_var=raw.get("api_key_env_var") or None,
             base_url=raw.get("base_url") or None,
             supports_reasoning_effort=raw.get("supports_reasoning_effort") is True,
+            legacy_max_tokens=raw.get("legacy_max_tokens") is True,
         )
 
     return providers
@@ -768,14 +773,12 @@ def _available_provider_references(settings: Settings) -> list[str]:
 
     add(settings.default_provider)
 
-    for name, provider in settings.providers.items():
-        if provider_is_available(provider):
-            add(name)
+    for name in settings.providers:
+        add(name)
 
     for provider_id in list_env_discoverable_providers():
-        if provider_id in configured_types_with_credentials or not provider_api_key_from_env(provider_id):
-            continue
-        add(provider_id)
+        if provider_id not in configured_types_with_credentials:
+            add(provider_id)
 
     return available
 
@@ -825,6 +828,8 @@ def _resolve_provider_runtime(
     supports_effort = adapter.supports_reasoning_effort or bool(
         provider_config and provider_config.supports_reasoning_effort and isinstance(adapter, OpenAIChatAdapter)
     )
+    # The legacy max_tokens opt-in only applies to generic openai_chat providers.
+    legacy_max_tokens = bool(provider_config and provider_config.legacy_max_tokens and provider_type == "openai_chat")
     resolved_api_key = api_key
     if not resolved_api_key and provider_config:
         if env_name := provider_config.api_key_env_var:
@@ -851,5 +856,6 @@ def _resolve_provider_runtime(
         reasoning_effort=None,
         model_config=model_config,
         supports_reasoning_effort=supports_effort,
+        legacy_max_tokens=legacy_max_tokens,
         reasoning_efforts=reasoning_efforts,
     )

mycode_cli/main.py

@@ -5,9 +5,9 @@ from __future__ import annotations
 import asyncio
 import os
 import sys
-from contextlib import suppress
+from contextlib import aclosing, suppress
 from dataclasses import dataclass, replace
-from typing import Annotated, Any, Literal
+from typing import TYPE_CHECKING, Annotated, Any, Literal
 from uuid import uuid4
 
 import typer
@@ -28,8 +28,9 @@ from mycode_cli.permissions import PERMISSION_DENIED_BY_USER_OUTPUT, PERMISSION_
 from mycode_cli.sessions import SessionStore
 
 from .runtime import build_agent
-from .tui.chat import TerminalChat
-from .tui.render import TerminalView
+
+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")
@@ -106,13 +107,14 @@ async def run_noninteractive(agent: Agent, message: str, *, store: SessionStore,
             latest_assistant = payload
 
     error_message = ""
-    async for event in agent.achat(message, on_persist=track):
-        if event.type == "error":
-            error_message = str(event.data.get("message") or "agent error")
-        elif event.type == "tool_done" and event.data.get("is_error"):
-            output = str(event.data.get("output") or "")
-            if output in {PERMISSION_DENIED_OUTPUT, PERMISSION_DENIED_BY_USER_OUTPUT}:
-                error_message = output
+    async with aclosing(agent.achat(message, on_persist=track)) as stream:
+        async for event in stream:
+            if event.type == "error":
+                error_message = str(event.data.get("message") or "agent error")
+            elif event.type == "tool_done" and event.data.get("is_error"):
+                output = str(event.data.get("output") or "")
+                if output in {PERMISSION_DENIED_OUTPUT, PERMISSION_DENIED_BY_USER_OUTPUT}:
+                    error_message = output
 
     reply = ""
     if latest_assistant:
@@ -157,6 +159,8 @@ 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")
 
@@ -244,6 +248,8 @@ def chat(
     if ctx.invoked_subcommand is not None:
         return
 
+    from .tui.chat import TerminalChat
+
     setup = _bootstrap(
         provider=provider,
         model=model,
@@ -323,6 +329,7 @@ def web(
     resolved_port = port or settings.port
 
     import uvicorn
+    from uvicorn.config import LOGGING_CONFIG
 
     app_factory = "mycode_cli.server.app:create_web_app"
     if dev:
@@ -334,6 +341,11 @@ def web(
         port=resolved_port,
         reload=dev,
         factory=True,
+        timeout_graceful_shutdown=5,
+        log_config={
+            **LOGGING_CONFIG,
+            "root": {"handlers": ["default"], "level": "INFO"},
+        },
     )
 
 
@@ -343,6 +355,8 @@ def session_list(
 ) -> None:
     """List saved sessions."""
 
+    from .tui.render import TerminalView
+
     cwd = os.path.abspath(os.getcwd())
     store = SessionStore(data_dir=resolve_sessions_dir())
     view = TerminalView()

mycode_cli/permissions.py

@@ -13,7 +13,6 @@ from mycode_cli.config import PermissionConfig, PermissionLevel, Settings
 from mycode_cli.system_prompt import discover_skills
 from mycode_cli.workspace import CliDeps, resolve_path
 
-PermissionTier = Literal["readonly", "safe", "standard", "yolo"]
 PermissionDecision = Literal["allow", "ask", "deny"]
 ToolReviewDecision = Literal["allow", "deny"]
 
@@ -54,7 +53,7 @@ _FIND_DANGEROUS_FLAGS = {
 
 
 class PermissionCheck(NamedTuple):
-    tier: PermissionTier
+    tier: PermissionLevel
     preview: str
 
 
@@ -102,10 +101,8 @@ def build_permission_hooks(
     return hooks
 
 
-def permission_decision(permission: PermissionConfig, tier: PermissionTier) -> PermissionDecision:
-    if permission.level == "yolo":
-        return "allow"
-    if tier != "yolo" and _LEVEL_RANK[tier] <= _LEVEL_RANK[permission.level]:
+def permission_decision(permission: PermissionConfig, tier: PermissionLevel) -> PermissionDecision:
+    if _LEVEL_RANK[tier] <= _LEVEL_RANK[permission.level]:
         return "allow"
     return permission.mode
 
@@ -147,7 +144,7 @@ def classify_tool(
     return PermissionCheck("yolo", ctx.tool_name)
 
 
-def _classify_bash(command: str) -> PermissionTier:
+def _classify_bash(command: str) -> PermissionLevel:
     if not command:
         return "yolo"
     # Newlines and shell expansion bypass static analysis; treat as compound.

mycode_cli/runtime.py

@@ -5,7 +5,7 @@ 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
+from mycode_cli.sessions import SessionStore, sum_session_cost
 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
@@ -24,18 +24,7 @@ async def load_session_cost(store: SessionStore, session_id: str) -> float | Non
     discarded by rewind. Records without a cost are skipped.
     """
 
-    total: float | None = None
-    for message in await store.load_raw_messages(session_id):
-        if message.get("role") not in {"assistant", "compact"}:
-            continue
-        meta = message.get("meta") or {}
-        cost = meta.get("cost")
-        if not isinstance(cost, dict):
-            continue
-        request_total = cost.get("total")
-        if isinstance(request_total, int | float):
-            total = sum_known_costs(total, float(request_total))
-    return total
+    return sum_session_cost(await store.load_raw_messages(session_id))
 
 
 def build_agent(
@@ -65,6 +54,7 @@ def build_agent(
         api_base=resolved_provider.api_base,
         reasoning_effort=resolved_provider.reasoning_effort,
         supports_reasoning_effort=resolved_provider.supports_reasoning_effort,
+        legacy_max_tokens=resolved_provider.legacy_max_tokens,
         max_tokens=model_config.max_output_tokens if model_config else None,
         context_window=model_config.context_window if model_config else None,
         supports_image_input=model_config.supports_image_input if model_config else None,

mycode_cli/server/app.py

@@ -1,20 +1,24 @@
 """FastAPI application entry point."""
 
+import asyncio
 import logging
-from collections.abc import Sequence
+from collections.abc import AsyncGenerator, Sequence
+from contextlib import asynccontextmanager
 from pathlib import Path
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 
+from mycode_cli.config import resolve_sessions_dir
 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
+from mycode_cli.server.run_manager import RunManager
+from mycode_cli.sessions import SessionStore
 
 logger = logging.getLogger(__name__)
-logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
 DEV_CORS_ORIGINS = ("http://localhost:5173", "http://127.0.0.1:5173")
 
 
@@ -24,9 +28,20 @@ def web_static_path() -> Path:
     return Path(__file__).resolve().parent / "static"
 
 
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None]:
+    app.state.store = await asyncio.to_thread(SessionStore, data_dir=resolve_sessions_dir())
+    runs = RunManager()
+    app.state.runs = runs
+    try:
+        yield
+    finally:
+        await runs.aclose()
+
+
 def create_app(*, serve_web: bool = True, cors_origins: Sequence[str] = ()) -> FastAPI:
     """Create the FastAPI app."""
-    application = FastAPI(title="mycode")
+    application = FastAPI(title="mycode", lifespan=lifespan)
 
     if cors_origins:
         application.add_middleware(

mycode_cli/server/deps.py

@@ -3,12 +3,10 @@
 from __future__ import annotations
 
 import os
-from functools import cache
-from typing import Annotated
+from typing import Annotated, cast
 
-from fastapi import Depends, HTTPException
+from fastapi import Depends, HTTPException, Request
 
-from mycode_cli.config import resolve_sessions_dir
 from mycode_cli.server.run_manager import RunManager
 from mycode_cli.sessions import SessionStore
 
@@ -22,18 +20,16 @@ def resolve_workspace_cwd(raw: str | None) -> str:
     return cwd
 
 
-@cache
-def get_store() -> SessionStore:
-    """Return the shared session store for server requests."""
+async def get_store(request: Request) -> SessionStore:
+    """Return this application's session store."""
 
-    return SessionStore(data_dir=resolve_sessions_dir())
+    return cast(SessionStore, request.app.state.store)
 
 
-@cache
-def get_run_manager() -> RunManager:
-    """Return the shared in-process run manager."""
+async def get_run_manager(request: Request) -> RunManager:
+    """Return this application's run manager."""
 
-    return RunManager()
+    return cast(RunManager, request.app.state.runs)
 
 
 StoreDep = Annotated[SessionStore, Depends(get_store)]

mycode_cli/server/routers/chat.py

@@ -63,7 +63,7 @@ router = APIRouter()
 def _resolve_workspace_attachment_path(rel_path: str, *, cwd: str) -> Path:
     base = resolve_path(".", cwd=cwd)
     path = resolve_path(rel_path, cwd=cwd)
-    if base != path and not path.is_relative_to(base):
+    if not path.is_relative_to(base):
         raise HTTPException(status_code=400, detail=f"path outside workspace: {rel_path}")
     return path
 
@@ -97,7 +97,9 @@ async def _build_user_message(chat: ChatRequest, cwd: str) -> ConversationMessag
     for block in chat.input:
         if block.type == "text":
             if block.path:
-                blocks.extend(_read_workspace_text_attachment(block.path, name=block.name, cwd=cwd))
+                blocks.extend(
+                    await asyncio.to_thread(_read_workspace_text_attachment, block.path, name=block.name, cwd=cwd)
+                )
                 continue
             text = block.text or ""
             if block.is_attachment:
@@ -145,11 +147,8 @@ def _validate_rewind_request(
     *,
     session: dict[str, Any] | None,
     messages: list[ConversationMessage],
-    rewind_to: int | None,
+    rewind_to: int,
 ) -> None:
-    if rewind_to is None:
-        return
-
     if session is None:
         raise HTTPException(status_code=400, detail="rewind_to requires an existing session")
 
@@ -236,10 +235,11 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep) -> ChatR
                 detail={"message": "session already has a running task", "run": active},
             )
 
-        data = await store.load_session(session_id)
-        session = cast(dict[str, Any] | None, data["session"] if data else None)
-        existing_messages = data["messages"] if data else []
-        _validate_rewind_request(session=session, messages=existing_messages, rewind_to=chat.rewind_to)
+        if chat.rewind_to is not None:
+            data = await store.load_session(session_id)
+            session = cast(dict[str, Any] | None, data["session"] if data else None)
+            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
@@ -374,6 +374,7 @@ async def compact_session(
                 session_id=session_id,
                 base_messages=agent.messages,
                 agent=agent,
+                session_cost_base=data["session_cost"],
                 on_complete=store.touch,
             )
         except ActiveRunError as exc:

mycode_cli/server/routers/sessions.py

@@ -9,7 +9,6 @@ from fastapi import APIRouter, HTTPException, Query
 from fastapi import Path as PathParam
 
 from mycode.messages import ConversationMessage
-from mycode_cli.runtime import load_session_cost
 from mycode_cli.server.deps import RunManagerDep, StoreDep, resolve_workspace_cwd
 from mycode_cli.server.schemas import SessionCreateRequest, StatusResponse
 
@@ -57,19 +56,18 @@ async def load_session(
 ) -> dict[str, Any]:
     """Load a session, overlaying any active in-memory run state."""
 
-    data = await store.load_session(session_id)
-    # Folded from the raw JSONL: counts everything persisted so far, including
-    # rewound-away turns. During an active run the SSE usage events supersede it.
-    session_cost = await load_session_cost(store, session_id)
-    active = await runs.snapshot_session(session_id)
-    if active:
-        return {
-            "session": data["session"] if data else None,
-            "messages": _redact_document_data(active["messages"]),
-            "session_cost": session_cost,
-            "active_run": active["run"],
-            "pending_events": active["pending_events"],
-        }
+    async with runs.session_operation(session_id):
+        active = await runs.snapshot_session(session_id)
+        if active:
+            return {
+                "session": await store.load_metadata(session_id),
+                "messages": _redact_document_data(active["messages"]),
+                "session_cost": active["session_cost"],
+                "active_run": active["run"],
+                "pending_events": active["pending_events"],
+            }
+
+        data = await store.load_session(session_id)
 
     if data is None:
         return {"session": None, "messages": [], "session_cost": None, "active_run": None, "pending_events": []}
@@ -77,7 +75,7 @@ async def load_session(
     return {
         "session": data["session"],
         "messages": _redact_document_data(data["messages"]),
-        "session_cost": session_cost,
+        "session_cost": data["session_cost"],
         "active_run": None,
         "pending_events": [],
     }

mycode_cli/server/routers/settings.py

@@ -168,14 +168,16 @@ def put_settings_endpoint(payload: SettingsRequest) -> dict[str, Any]:
     # Three-state api_key merge: when the UI sends null / omits it, we copy the
     # existing literal forward so secrets survive a save without round-tripping.
     existing_providers = existing.get("providers") or {}
-    for name, entry in (incoming.get("providers") or {}).items():
-        if not isinstance(entry, dict) or entry.get("api_key") is not None:
-            continue
-        prior = existing_providers.get(name) if isinstance(existing_providers, dict) else None
-        if isinstance(prior, dict) and "api_key" in prior:
-            entry["api_key"] = prior["api_key"]
-        else:
-            entry.pop("api_key", None)
+    incoming_providers = incoming.get("providers")
+    if isinstance(incoming_providers, dict):
+        for name, entry in incoming_providers.items():
+            if not isinstance(entry, dict) or entry.get("api_key") is not None:
+                continue
+            prior = existing_providers.get(name) if isinstance(existing_providers, dict) else None
+            if isinstance(prior, dict) and "api_key" in prior:
+                entry["api_key"] = prior["api_key"]
+            else:
+                entry.pop("api_key", None)
 
     existing_web = existing.get("web") or {}
     incoming_web = incoming.get("web") or {}

mycode_cli/server/routers/workspaces.py

@@ -121,7 +121,7 @@ def list_workspace_files(
 
     target = (base / dir).resolve(strict=False)
     # Reject traversal outside cwd after resolving symlinks.
-    if target != base and not target.is_relative_to(base):
+    if not target.is_relative_to(base):
         return {"entries": [], "truncated": False, "error": "path outside workspace"}
     if not target.is_dir():
         return {"entries": [], "truncated": False, "error": "not a directory"}
@@ -133,7 +133,7 @@ def list_workspace_files(
                 continue
             try:
                 resolved = entry.resolve()
-                if resolved != base and not resolved.is_relative_to(base):
+                if not resolved.is_relative_to(base):
                     continue
                 is_dir = entry.is_dir()
             except OSError: