kimi-cli 0.41__py3-none-any.whl → 0.42__py3-none-any.whl

kimi_cli/metadata.py

@@ -1,8 +1,6 @@
 import json
-import uuid
 from hashlib import md5
 from pathlib import Path
-from typing import NamedTuple
 
 from pydantic import BaseModel, Field
 
@@ -33,10 +31,12 @@ class WorkDirMeta(BaseModel):
 class Metadata(BaseModel):
     """Kimi metadata structure."""
 
-    work_dirs: list[WorkDirMeta] = Field(default_factory=list, description="Work directory list")
+    work_dirs: list[WorkDirMeta] = Field(
+        default_factory=list[WorkDirMeta], description="Work directory list"
+    )
 
 
-def _load_metadata() -> Metadata:
+def load_metadata() -> Metadata:
     metadata_file = get_metadata_file()
     logger.debug("Loading metadata from file: {file}", file=metadata_file)
     if not metadata_file.exists():
@@ -47,71 +47,8 @@ def _load_metadata() -> Metadata:
         return Metadata(**data)
 
 
-def _save_metadata(metadata: Metadata):
+def save_metadata(metadata: Metadata):
     metadata_file = get_metadata_file()
     logger.debug("Saving metadata to file: {file}", file=metadata_file)
     with open(metadata_file, "w", encoding="utf-8") as f:
         json.dump(metadata.model_dump(), f, indent=2, ensure_ascii=False)
-
-
-class Session(NamedTuple):
-    """A session of a work directory."""
-
-    id: str
-    work_dir: WorkDirMeta
-    history_file: Path
-
-
-def new_session(work_dir: Path, _history_file: Path | None = None) -> Session:
-    """Create a new session for a work directory."""
-    logger.debug("Creating new session for work directory: {work_dir}", work_dir=work_dir)
-
-    metadata = _load_metadata()
-    work_dir_meta = next((wd for wd in metadata.work_dirs if wd.path == str(work_dir)), None)
-    if work_dir_meta is None:
-        work_dir_meta = WorkDirMeta(path=str(work_dir))
-        metadata.work_dirs.append(work_dir_meta)
-
-    session_id = str(uuid.uuid4())
-    if _history_file is None:
-        history_file = work_dir_meta.sessions_dir / f"{session_id}.jsonl"
-        work_dir_meta.last_session_id = session_id
-    else:
-        logger.warning("Using provided history file: {history_file}", history_file=_history_file)
-        _history_file.parent.mkdir(parents=True, exist_ok=True)
-        if _history_file.exists():
-            assert _history_file.is_file()
-        history_file = _history_file
-
-    if history_file.exists():
-        # truncate if exists
-        logger.warning(
-            "History file already exists, truncating: {history_file}", history_file=history_file
-        )
-        history_file.unlink()
-        history_file.touch()
-
-    _save_metadata(metadata)
-    return Session(id=session_id, work_dir=work_dir_meta, history_file=history_file)
-
-
-def continue_session(work_dir: Path) -> Session | None:
-    """Get the last session for a work directory."""
-    logger.debug("Continuing session for work directory: {work_dir}", work_dir=work_dir)
-
-    metadata = _load_metadata()
-    work_dir_meta = next((wd for wd in metadata.work_dirs if wd.path == str(work_dir)), None)
-    if work_dir_meta is None:
-        logger.debug("Work directory never been used")
-        return None
-    if work_dir_meta.last_session_id is None:
-        logger.debug("Work directory never had a session")
-        return None
-
-    logger.debug(
-        "Found last session for work directory: {session_id}",
-        session_id=work_dir_meta.last_session_id,
-    )
-    session_id = work_dir_meta.last_session_id
-    history_file = work_dir_meta.sessions_dir / f"{session_id}.jsonl"
-    return Session(id=session_id, work_dir=work_dir_meta, history_file=history_file)

kimi_cli/session.py

@@ -0,0 +1,81 @@
+import uuid
+from pathlib import Path
+from typing import NamedTuple
+
+from kimi_cli.metadata import WorkDirMeta, load_metadata, save_metadata
+from kimi_cli.utils.logging import logger
+
+
+class Session(NamedTuple):
+    """A session of a work directory."""
+
+    id: str
+    work_dir: Path
+    history_file: Path
+
+    @staticmethod
+    def create(work_dir: Path, _history_file: Path | None = None) -> "Session":
+        """Create a new session for a work directory."""
+        logger.debug("Creating new session for work directory: {work_dir}", work_dir=work_dir)
+
+        metadata = load_metadata()
+        work_dir_meta = next((wd for wd in metadata.work_dirs if wd.path == str(work_dir)), None)
+        if work_dir_meta is None:
+            work_dir_meta = WorkDirMeta(path=str(work_dir))
+            metadata.work_dirs.append(work_dir_meta)
+
+        session_id = str(uuid.uuid4())
+        if _history_file is None:
+            history_file = work_dir_meta.sessions_dir / f"{session_id}.jsonl"
+            work_dir_meta.last_session_id = session_id
+        else:
+            logger.warning(
+                "Using provided history file: {history_file}", history_file=_history_file
+            )
+            _history_file.parent.mkdir(parents=True, exist_ok=True)
+            if _history_file.exists():
+                assert _history_file.is_file()
+            history_file = _history_file
+
+        if history_file.exists():
+            # truncate if exists
+            logger.warning(
+                "History file already exists, truncating: {history_file}", history_file=history_file
+            )
+            history_file.unlink()
+            history_file.touch()
+
+        save_metadata(metadata)
+
+        return Session(
+            id=session_id,
+            work_dir=work_dir,
+            history_file=history_file,
+        )
+
+    @staticmethod
+    def continue_(work_dir: Path) -> "Session | None":
+        """Get the last session for a work directory."""
+        logger.debug("Continuing session for work directory: {work_dir}", work_dir=work_dir)
+
+        metadata = load_metadata()
+        work_dir_meta = next((wd for wd in metadata.work_dirs if wd.path == str(work_dir)), None)
+        if work_dir_meta is None:
+            logger.debug("Work directory never been used")
+            return None
+        if work_dir_meta.last_session_id is None:
+            logger.debug("Work directory never had a session")
+            return None
+
+        logger.debug(
+            "Found last session for work directory: {session_id}",
+            session_id=work_dir_meta.last_session_id,
+        )
+        session_id = work_dir_meta.last_session_id
+        history_file = work_dir_meta.sessions_dir / f"{session_id}.jsonl"
+
+        return Session(
+            id=session_id,
+            work_dir=work_dir,
+            history_file=history_file,
+        )

kimi_cli/soul/agent.py

@@ -9,10 +9,10 @@ from kosong.tooling import CallableTool, CallableTool2, Toolset
 
 from kimi_cli.agentspec import ResolvedAgentSpec, load_agent_spec
 from kimi_cli.config import Config
-from kimi_cli.metadata import Session
+from kimi_cli.session import Session
 from kimi_cli.soul.approval import Approval
 from kimi_cli.soul.denwarenji import DenwaRenji
-from kimi_cli.soul.globals import AgentGlobals, BuiltinSystemPromptArgs
+from kimi_cli.soul.runtime import BuiltinSystemPromptArgs, Runtime
 from kimi_cli.soul.toolset import CustomToolset
 from kimi_cli.tools.mcp import MCPTool
 from kimi_cli.utils.logging import logger
@@ -26,27 +26,18 @@ class Agent(NamedTuple):
     toolset: Toolset
 
 
-async def load_agent_with_mcp(
+async def load_agent(
     agent_file: Path,
-    globals_: AgentGlobals,
+    runtime: Runtime,
+    *,
     mcp_configs: list[dict[str, Any]],
-) -> Agent:
-    agent = load_agent(agent_file, globals_)
-    assert isinstance(agent.toolset, CustomToolset)
-    if mcp_configs:
-        await _load_mcp_tools(agent.toolset, mcp_configs)
-    return agent
-
-
-def load_agent(
-    agent_file: Path,
-    globals_: AgentGlobals,
 ) -> Agent:
     """
     Load agent from specification file.
 
     Raises:
-        ValueError: If the agent spec is not valid.
+        FileNotFoundError: If the agent spec file does not exist.
+        AgentSpecError: If the agent spec is not valid.
     """
     logger.info("Loading agent: {agent_file}", agent_file=agent_file)
     agent_spec = load_agent_spec(agent_file)
@@ -54,17 +45,17 @@ def load_agent(
     system_prompt = _load_system_prompt(
         agent_spec.system_prompt_path,
         agent_spec.system_prompt_args,
-        globals_.builtin_args,
+        runtime.builtin_args,
     )
 
     tool_deps = {
         ResolvedAgentSpec: agent_spec,
-        AgentGlobals: globals_,
-        Config: globals_.config,
-        BuiltinSystemPromptArgs: globals_.builtin_args,
-        Session: globals_.session,
-        DenwaRenji: globals_.denwa_renji,
-        Approval: globals_.approval,
+        Runtime: runtime,
+        Config: runtime.config,
+        BuiltinSystemPromptArgs: runtime.builtin_args,
+        Session: runtime.session,
+        DenwaRenji: runtime.denwa_renji,
+        Approval: runtime.approval,
     }
     tools = agent_spec.tools
     if agent_spec.exclude_tools:
@@ -75,6 +66,10 @@ def load_agent(
     if bad_tools:
         raise ValueError(f"Invalid tools: {bad_tools}")
 
+    assert isinstance(toolset, CustomToolset)
+    if mcp_configs:
+        await _load_mcp_tools(toolset, mcp_configs)
+
     return Agent(
         name=agent_spec.name,
         system_prompt=system_prompt,

kimi_cli/soul/context.py

@@ -19,11 +19,6 @@ class Context:
         self._next_checkpoint_id: int = 0
         """The ID of the next checkpoint, starting from 0, incremented after each checkpoint."""
 
-    @property
-    def file_backend(self) -> Path:
-        """The JSONL file backend of the context."""
-        return self._file_backend
-
     async def restore(self) -> bool:
         logger.debug("Restoring context from file: {file_backend}", file_backend=self._file_backend)
         if self._history:

kimi_cli/soul/kimisoul.py

@@ -16,13 +16,12 @@ from kosong.chat_provider import (
 from kosong.tooling import ToolResult
 from tenacity import RetryCallState, retry_if_exception, stop_after_attempt, wait_exponential_jitter
 
-from kimi_cli.config import LoopControl
 from kimi_cli.soul import LLMNotSet, MaxStepsReached, Soul, StatusSnapshot, wire_send
 from kimi_cli.soul.agent import Agent
 from kimi_cli.soul.compaction import SimpleCompaction
 from kimi_cli.soul.context import Context
-from kimi_cli.soul.globals import AgentGlobals
 from kimi_cli.soul.message import system, tool_result_to_messages
+from kimi_cli.soul.runtime import Runtime
 from kimi_cli.tools.dmail import NAME as SendDMail_NAME
 from kimi_cli.tools.utils import ToolRejectedError
 from kimi_cli.utils.logging import logger
@@ -43,30 +42,29 @@ class KimiSoul(Soul):
     def __init__(
         self,
         agent: Agent,
-        agent_globals: AgentGlobals,
+        runtime: Runtime,
         *,
         context: Context,
-        loop_control: LoopControl,
     ):
         """
         Initialize the soul.
 
         Args:
             agent (Agent): The agent to run.
-            agent_globals (AgentGlobals): Global states and parameters.
+            runtime (Runtime): Runtime parameters and states.
             context (Context): The context of the agent.
             loop_control (LoopControl): The control parameters for the agent loop.
         """
         self._agent = agent
-        self._agent_globals = agent_globals
-        self._denwa_renji = agent_globals.denwa_renji
-        self._approval = agent_globals.approval
+        self._runtime = runtime
+        self._denwa_renji = runtime.denwa_renji
+        self._approval = runtime.approval
         self._context = context
-        self._loop_control = loop_control
+        self._loop_control = runtime.config.loop_control
         self._compaction = SimpleCompaction()  # TODO: maybe configurable and composable
         self._reserved_tokens = RESERVED_TOKENS
-        if self._agent_globals.llm is not None:
-            assert self._reserved_tokens <= self._agent_globals.llm.max_context_size
+        if self._runtime.llm is not None:
+            assert self._reserved_tokens <= self._runtime.llm.max_context_size
 
         for tool in agent.toolset.tools:
             if tool.name == SendDMail_NAME:
@@ -81,7 +79,7 @@ class KimiSoul(Soul):
 
     @property
     def model(self) -> str:
-        return self._agent_globals.llm.chat_provider.model_name if self._agent_globals.llm else ""
+        return self._runtime.llm.chat_provider.model_name if self._runtime.llm else ""
 
     @property
     def status(self) -> StatusSnapshot:
@@ -89,15 +87,15 @@ class KimiSoul(Soul):
 
     @property
     def _context_usage(self) -> float:
-        if self._agent_globals.llm is not None:
-            return self._context.token_count / self._agent_globals.llm.max_context_size
+        if self._runtime.llm is not None:
+            return self._context.token_count / self._runtime.llm.max_context_size
         return 0.0
 
     async def _checkpoint(self):
         await self._context.checkpoint(self._checkpoint_with_user_message)
 
     async def run(self, user_input: str):
-        if self._agent_globals.llm is None:
+        if self._runtime.llm is None:
             raise LLMNotSet()
 
         await self._checkpoint()  # this creates the checkpoint 0 on first run
@@ -107,7 +105,7 @@ class KimiSoul(Soul):
 
     async def _agent_loop(self):
         """The main agent loop for one run."""
-        assert self._agent_globals.llm is not None
+        assert self._runtime.llm is not None
 
         async def _pipe_approval_to_wire():
             while True:
@@ -126,7 +124,7 @@ class KimiSoul(Soul):
                 # compact the context if needed
                 if (
                     self._context.token_count + self._reserved_tokens
-                    >= self._agent_globals.llm.max_context_size
+                    >= self._runtime.llm.max_context_size
                 ):
                     logger.info("Context too long, compacting...")
                     wire_send(CompactionBegin())
@@ -159,8 +157,8 @@ class KimiSoul(Soul):
     async def _step(self) -> bool:
         """Run an single step and return whether the run should be stopped."""
         # already checked in `run`
-        assert self._agent_globals.llm is not None
-        chat_provider = self._agent_globals.llm.chat_provider
+        assert self._runtime.llm is not None
+        chat_provider = self._runtime.llm.chat_provider
 
         @tenacity.retry(
             retry=retry_if_exception(self._is_retryable_error),
@@ -255,9 +253,9 @@ class KimiSoul(Soul):
             reraise=True,
         )
         async def _compact_with_retry() -> Sequence[Message]:
-            if self._agent_globals.llm is None:
+            if self._runtime.llm is None:
                 raise LLMNotSet()
-            return await self._compaction.compact(self._context.history, self._agent_globals.llm)
+            return await self._compaction.compact(self._context.history, self._runtime.llm)
 
         compacted_messages = await _compact_with_retry()
         await self._context.revert_to(0)

kimi_cli/soul/{globals.py → runtime.py}

@@ -6,7 +6,7 @@ from typing import NamedTuple
 
 from kimi_cli.config import Config
 from kimi_cli.llm import LLM
-from kimi_cli.metadata import Session
+from kimi_cli.session import Session
 from kimi_cli.soul.approval import Approval
 from kimi_cli.soul.denwarenji import DenwaRenji
 from kimi_cli.utils.logging import logger
@@ -58,7 +58,7 @@ def _list_work_dir(work_dir: Path) -> str:
     return ls.stdout.strip()
 
 
-class AgentGlobals(NamedTuple):
+class Runtime(NamedTuple):
     """Agent globals."""
 
     config: Config
@@ -68,22 +68,24 @@ class AgentGlobals(NamedTuple):
     denwa_renji: DenwaRenji
     approval: Approval
 
-    @classmethod
+    @staticmethod
     async def create(
-        cls, config: Config, llm: LLM | None, session: Session, yolo: bool
-    ) -> "AgentGlobals":
-        work_dir = Path(session.work_dir.path)
+        config: Config,
+        llm: LLM | None,
+        session: Session,
+        yolo: bool,
+    ) -> "Runtime":
         # FIXME: do these asynchronously
-        ls_output = _list_work_dir(work_dir)
-        agents_md = load_agents_md(work_dir) or ""
+        ls_output = _list_work_dir(session.work_dir)
+        agents_md = load_agents_md(session.work_dir) or ""
 
-        return cls(
+        return Runtime(
             config=config,
             llm=llm,
             session=session,
             builtin_args=BuiltinSystemPromptArgs(
                 KIMI_NOW=datetime.now().astimezone().isoformat(),
-                KIMI_WORK_DIR=work_dir,
+                KIMI_WORK_DIR=session.work_dir,
                 KIMI_WORK_DIR_LS=ls_output,
                 KIMI_AGENTS_MD=agents_md,
             ),

kimi_cli/tools/file/glob.py

@@ -8,7 +8,7 @@ import aiofiles.os
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
 
-from kimi_cli.soul.globals import BuiltinSystemPromptArgs
+from kimi_cli.soul.runtime import BuiltinSystemPromptArgs
 from kimi_cli.tools.utils import load_desc
 
 MAX_MATCHES = 1000

kimi_cli/tools/file/patch.py

@@ -7,7 +7,7 @@ from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
 
 from kimi_cli.soul.approval import Approval
-from kimi_cli.soul.globals import BuiltinSystemPromptArgs
+from kimi_cli.soul.runtime import BuiltinSystemPromptArgs
 from kimi_cli.tools.file import FileActions
 from kimi_cli.tools.utils import ToolRejectedError
 

kimi_cli/tools/file/read.py

@@ -5,7 +5,7 @@ import aiofiles
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
 
-from kimi_cli.soul.globals import BuiltinSystemPromptArgs
+from kimi_cli.soul.runtime import BuiltinSystemPromptArgs
 from kimi_cli.tools.utils import load_desc, truncate_line
 
 MAX_LINES = 1000

kimi_cli/tools/file/replace.py

@@ -6,7 +6,7 @@ from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
 
 from kimi_cli.soul.approval import Approval
-from kimi_cli.soul.globals import BuiltinSystemPromptArgs
+from kimi_cli.soul.runtime import BuiltinSystemPromptArgs
 from kimi_cli.tools.file import FileActions
 from kimi_cli.tools.utils import ToolRejectedError
 

kimi_cli/tools/file/write.py

@@ -6,7 +6,7 @@ from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
 
 from kimi_cli.soul.approval import Approval
-from kimi_cli.soul.globals import BuiltinSystemPromptArgs
+from kimi_cli.soul.runtime import BuiltinSystemPromptArgs
 from kimi_cli.tools.file import FileActions
 from kimi_cli.tools.utils import ToolRejectedError
 

kimi_cli/tools/task/__init__.py

@@ -5,12 +5,12 @@ from typing import override
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
 
-from kimi_cli.agentspec import ResolvedAgentSpec
+from kimi_cli.agentspec import ResolvedAgentSpec, SubagentSpec
 from kimi_cli.soul import MaxStepsReached, get_wire_or_none, run_soul
 from kimi_cli.soul.agent import Agent, load_agent
 from kimi_cli.soul.context import Context
-from kimi_cli.soul.globals import AgentGlobals
 from kimi_cli.soul.kimisoul import KimiSoul
+from kimi_cli.soul.runtime import Runtime
 from kimi_cli.tools.utils import load_desc
 from kimi_cli.utils.message import message_extract_text
 from kimi_cli.utils.path import next_available_rotation
@@ -49,28 +49,36 @@ class Task(CallableTool2[Params]):
     name: str = "Task"
     params: type[Params] = Params
 
-    def __init__(self, agent_spec: ResolvedAgentSpec, agent_globals: AgentGlobals, **kwargs):
-        subagents: dict[str, Agent] = {}
-        descs = []
-
-        # load all subagents
-        for name, spec in agent_spec.subagents.items():
-            subagents[name] = load_agent(spec.path, agent_globals)
-            descs.append(f"- `{name}`: {spec.description}")
-
+    def __init__(self, agent_spec: ResolvedAgentSpec, runtime: Runtime, **kwargs):
         super().__init__(
             description=load_desc(
                 Path(__file__).parent / "task.md",
                 {
-                    "SUBAGENTS_MD": "\n".join(descs),
+                    "SUBAGENTS_MD": "\n".join(
+                        f"- `{name}`: {spec.description}"
+                        for name, spec in agent_spec.subagents.items()
+                    ),
                 },
             ),
             **kwargs,
         )
 
-        self._agent_globals = agent_globals
-        self._session = agent_globals.session
-        self._subagents = subagents
+        self._runtime = runtime
+        self._session = runtime.session
+        self._subagents: dict[str, Agent] = {}
+
+        try:
+            self._load_task = asyncio.create_task(self._load_subagents(agent_spec.subagents))
+        except RuntimeError:
+            # In case there's no running event loop, e.g., during synchronous tests
+            self._load_task = None
+            asyncio.run(self._load_subagents(agent_spec.subagents))
+
+    async def _load_subagents(self, subagent_specs: dict[str, SubagentSpec]) -> None:
+        """Load all subagents specified in the agent spec."""
+        for name, spec in subagent_specs.items():
+            agent = await load_agent(spec.path, self._runtime, mcp_configs=[])
+            self._subagents[name] = agent
 
     async def _get_subagent_history_file(self) -> Path:
         """Generate a unique history file path for subagent."""
@@ -85,6 +93,10 @@ class Task(CallableTool2[Params]):
 
     @override
     async def __call__(self, params: Params) -> ToolReturnType:
+        if self._load_task is not None:
+            await self._load_task
+            self._load_task = None
+
         if params.subagent_name not in self._subagents:
             return ToolError(
                 message=f"Subagent not found: {params.subagent_name}",
@@ -117,12 +129,7 @@ class Task(CallableTool2[Params]):
 
         subagent_history_file = await self._get_subagent_history_file()
         context = Context(file_backend=subagent_history_file)
-        soul = KimiSoul(
-            agent,
-            agent_globals=self._agent_globals,
-            context=context,
-            loop_control=self._agent_globals.config.loop_control,
-        )
+        soul = KimiSoul(agent, runtime=self._runtime, context=context)
 
         try:
             await run_soul(soul, prompt, _ui_loop_fn, asyncio.Event())

kimi_cli/tools/web/search.py

@@ -44,9 +44,11 @@ class SearchWeb(CallableTool2[Params]):
         if config.services.moonshot_search is not None:
             self._base_url = config.services.moonshot_search.base_url
             self._api_key = config.services.moonshot_search.api_key.get_secret_value()
+            self._custom_headers = config.services.moonshot_search.custom_headers
         else:
             self._base_url = ""
             self._api_key = ""
+            self._custom_headers = {}
 
     @override
     async def __call__(self, params: Params) -> ToolReturnType:
@@ -69,6 +71,7 @@ class SearchWeb(CallableTool2[Params]):
                     "User-Agent": USER_AGENT,
                     "Authorization": f"Bearer {self._api_key}",
                     "X-Msh-Tool-Call-Id": tool_call.id,
+                    **self._custom_headers,
                 },
                 json={
                     "text_query": params.query,

kimi_cli/ui/print/__init__.py

@@ -138,13 +138,15 @@ class PrintApp:
 
     async def _visualize_stream_json(self, wire: WireUISide, start_position: int):
         # TODO: be aware of context compaction
+        # FIXME: this is only a temporary impl, may miss the last lines of the context file
+        if not self.context_file.exists():
+            self.context_file.touch()
         try:
             async with aiofiles.open(self.context_file, encoding="utf-8") as f:
                 await f.seek(start_position)
                 while True:
                     should_end = False
-                    while wire._queue.qsize() > 0:
-                        msg = wire._queue.get_nowait()
+                    while (msg := wire.receive_nowait()) is not None:
                         if isinstance(msg, StepInterrupted):
                             should_end = True
 

kimi_cli/ui/shell/__init__.py

@@ -31,7 +31,7 @@ class ShellApp:
             logger.info("Running agent with command: {command}", command=command)
             return await self._run_soul_command(command)
 
-        self._start_auto_update_task()
+        self._start_background_task(self._auto_update())
 
         _print_welcome_info(self.soul.name or "Kimi CLI", self.soul.model, self.welcome_info)
 
@@ -191,10 +191,7 @@ class ShellApp:
             loop.remove_signal_handler(signal.SIGINT)
         return False
 
-    def _start_auto_update_task(self) -> None:
-        self._add_background_task(self._auto_update_background())
-
-    async def _auto_update_background(self) -> None:
+    async def _auto_update(self) -> None:
         toast("checking for updates...", duration=2.0)
         result = await do_update(print=False, check_only=True)
         if result == UpdateResult.UPDATE_AVAILABLE:
@@ -204,7 +201,7 @@ class ShellApp:
         elif result == UpdateResult.UPDATED:
             toast("auto updated, restart to use the new version", duration=5.0)
 
-    def _add_background_task(self, coro: Coroutine[Any, Any, Any]) -> asyncio.Task[Any]:
+    def _start_background_task(self, coro: Coroutine[Any, Any, Any]) -> asyncio.Task[Any]:
         task = asyncio.create_task(coro)
         self._background_tasks.add(task)