mycode-cli 0.15.0__tar.gz → 0.16.1__tar.gz

{mycode_cli-0.15.0 → mycode_cli-0.16.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mycode-cli
-Version: 0.15.0
+Version: 0.16.1
 Summary: Minimal coding agent CLI and web UI built on mycode-sdk.
 Project-URL: Homepage, https://github.com/legibet/mycode
 Project-URL: Repository, https://github.com/legibet/mycode
@@ -25,7 +25,7 @@ Requires-Dist: beautifulsoup4>=4.15.0
 Requires-Dist: fastapi>=0.139.0
 Requires-Dist: httpx2>=2.10.0
 Requires-Dist: markdownify>=1.2.3
-Requires-Dist: mycode-sdk==0.15.0
+Requires-Dist: mycode-sdk==0.16.1
 Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: pydantic>=2.13.4
 Requires-Dist: pyyaml>=6.0.3

{mycode_cli-0.15.0 → mycode_cli-0.16.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mycode-cli"
-version = "0.15.0"
+version = "0.16.1"
 description = "Minimal coding agent CLI and web UI built on mycode-sdk."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -26,7 +26,7 @@ classifiers = [
 ]
 keywords = ["agent", "cli", "llm", "coding-agent", "fastapi"]
 dependencies = [
-    "mycode-sdk==0.15.0",
+    "mycode-sdk==0.16.1",
     "fastapi>=0.139.0",
     "uvicorn[standard]>=0.51.0",
     "rich>=15.0.0",

{mycode_cli-0.15.0 → mycode_cli-0.16.1}/src/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, ...] = ()
 
 
@@ -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)
@@ -519,6 +529,8 @@ def get_settings(cwd: str | None = None) -> Settings:
                 merged["base_url"] = raw["base_url"]
             if "supports_reasoning_effort" in raw:
                 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
 
@@ -623,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
@@ -815,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:
@@ -841,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-0.15.0 → mycode_cli-0.16.1}/src/mycode_cli/main.py

@@ -5,7 +5,7 @@ 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 TYPE_CHECKING, Annotated, Any, Literal
 from uuid import uuid4
@@ -107,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:

{mycode_cli-0.15.0 → mycode_cli-0.16.1}/src/mycode_cli/runtime.py

@@ -54,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-0.15.0 → mycode_cli-0.16.1}/src/mycode_cli/server/run_manager.py

@@ -6,7 +6,7 @@ import asyncio
 import copy
 import time
 from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable
-from contextlib import asynccontextmanager
+from contextlib import aclosing, asynccontextmanager
 from dataclasses import dataclass, field
 from typing import Any, Literal, Protocol
 from uuid import uuid4
@@ -47,7 +47,7 @@ class RunAgent(Protocol):
 
     def cancel(self) -> None: ...
 
-    def achat(self, user_input: str | ConversationMessage) -> AsyncIterator[Event]: ...
+    def achat(self, user_input: str | ConversationMessage) -> AsyncGenerator[Event, None]: ...
 
     def acompact(self) -> Awaitable[ConversationMessage]: ...
 
@@ -355,12 +355,14 @@ class RunManager:
     async def _run(self, state: RunState) -> None:
         """Run the agent and store streamed events."""
 
-        # Agent entrypoints reset their cancellation flags for a new turn.
+        # A run can be stopped before the SDK operation has started.
         if state.cancel_requested:
+            await self._append_event(state, Event("cancelled", {}))
             await self._finish_run(state, status="cancelled")
             return
 
         last_error: str | None = None
+        cancelled = False
 
         try:
             if state.kind == "compact":
@@ -371,29 +373,32 @@ class RunManager:
                 await self._append_event(state, Event("compact", {}), compact_cost=sum_session_cost([marker]))
             else:
                 assert state.user_message is not None
-                async for event in state.agent.achat(state.user_message):
-                    if event.type == "retry":
-                        continue
-                    if event.type == "error":
-                        last_error = str(event.data.get("message") or "unknown error")
-                    await self._append_event(state, event)
+                async with aclosing(state.agent.achat(state.user_message)) as stream:
+                    async for event in stream:
+                        if event.type == "retry":
+                            continue
+                        if event.type == "error":
+                            last_error = str(event.data.get("message") or "unknown error")
+                        elif event.type == "cancelled":
+                            cancelled = True
+                            continue
+                        await self._append_event(state, event)
         except asyncio.CancelledError:
-            # BaseException, not caught by ``except Exception`` — without this
-            # branch ``_finish_run`` never runs and the active-session lock
-            # leaks (next /api/chat returns 409).
-            last_error = "cancelled"
+            # Manual compaction and external task cancellation both end the run.
+            cancelled = True
         except Exception as exc:
             # Reached by compact failures (e.g. nothing to compact, provider
-            # errors); chat runs surface errors as events instead.
+            # errors) and by persist/cleanup failures during a chat turn.
             last_error = str(exc)
             await self._append_event(state, Event("error", {"message": last_error}))
 
-        if state.cancel_requested or last_error == "cancelled":
-            await self._finish_run(state, status="cancelled", error=last_error)
+        if last_error is not None:
+            await self._finish_run(state, status="failed", error=last_error)
             return
 
-        if last_error:
-            await self._finish_run(state, status="failed", error=last_error)
+        if cancelled or state.cancel_requested:
+            await self._append_event(state, Event("cancelled", {}))
+            await self._finish_run(state, status="cancelled")
             return
 
         await self._finish_run(state, status="completed")