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

kimi_cli/tools/file/patch.py

@@ -6,8 +6,8 @@ import patch_ng
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
 
-from kimi_cli.agent import BuiltinSystemPromptArgs
 from kimi_cli.soul.approval import Approval
+from kimi_cli.soul.runtime import BuiltinSystemPromptArgs
 from kimi_cli.tools.file import FileActions
 from kimi_cli.tools.utils import ToolRejectedError
 
@@ -19,7 +19,7 @@ class Params(BaseModel):
 
 class PatchFile(CallableTool2[Params]):
     name: str = "PatchFile"
-    description: str = (Path(__file__).parent / "patch.md").read_text()
+    description: str = (Path(__file__).parent / "patch.md").read_text(encoding="utf-8")
     params: type[Params] = Params
 
     def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval, **kwargs):

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.agent 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

@@ -5,8 +5,8 @@ import aiofiles
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
 
-from kimi_cli.agent import BuiltinSystemPromptArgs
 from kimi_cli.soul.approval import Approval
+from kimi_cli.soul.runtime import BuiltinSystemPromptArgs
 from kimi_cli.tools.file import FileActions
 from kimi_cli.tools.utils import ToolRejectedError
 
@@ -29,7 +29,7 @@ class Params(BaseModel):
 
 class StrReplaceFile(CallableTool2[Params]):
     name: str = "StrReplaceFile"
-    description: str = (Path(__file__).parent / "replace.md").read_text()
+    description: str = (Path(__file__).parent / "replace.md").read_text(encoding="utf-8")
     params: type[Params] = Params
 
     def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval, **kwargs):

kimi_cli/tools/file/write.py

@@ -5,8 +5,8 @@ import aiofiles
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
 
-from kimi_cli.agent import BuiltinSystemPromptArgs
 from kimi_cli.soul.approval import Approval
+from kimi_cli.soul.runtime import BuiltinSystemPromptArgs
 from kimi_cli.tools.file import FileActions
 from kimi_cli.tools.utils import ToolRejectedError
 
@@ -26,7 +26,7 @@ class Params(BaseModel):
 
 class WriteFile(CallableTool2[Params]):
     name: str = "WriteFile"
-    description: str = (Path(__file__).parent / "write.md").read_text()
+    description: str = (Path(__file__).parent / "write.md").read_text(encoding="utf-8")
     params: type[Params] = Params
 
     def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval, **kwargs):

kimi_cli/tools/task/__init__.py

@@ -1,17 +1,21 @@
+import asyncio
 from pathlib import Path
 from typing import override
 
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
 
-from kimi_cli.agent import Agent, AgentGlobals, AgentSpec, load_agent
-from kimi_cli.soul import MaxStepsReached
+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.kimisoul import KimiSoul
-from kimi_cli.soul.wire import ApprovalRequest, Wire, WireMessage, get_wire_or_none
+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
+from kimi_cli.wire import WireUISide
+from kimi_cli.wire.message import ApprovalRequest, WireMessage
 
 # Maximum continuation attempts for task summary
 MAX_CONTINUE_ATTEMPTS = 1
@@ -45,29 +49,36 @@ class Task(CallableTool2[Params]):
     name: str = "Task"
     params: type[Params] = Params
 
-    def __init__(self, agent_spec: AgentSpec, agent_globals: AgentGlobals, **kwargs):
-        subagents: dict[str, Agent] = {}
-        descs = []
-
-        # load all subagents
-        assert agent_spec.subagents is not None, "Task tool expects 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."""
@@ -82,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}",
@@ -99,20 +114,25 @@ class Task(CallableTool2[Params]):
 
     async def _run_subagent(self, agent: Agent, prompt: str) -> ToolReturnType:
         """Run subagent with optional continuation for task summary."""
+        super_wire = get_wire_or_none()
+        assert super_wire is not None
+
+        def _super_wire_send(msg: WireMessage) -> None:
+            if isinstance(msg, ApprovalRequest):
+                super_wire.soul_side.send(msg)
+            # TODO: visualize subagent behavior by sending other messages in some way
+
+        async def _ui_loop_fn(wire: WireUISide) -> None:
+            while True:
+                msg = await wire.receive()
+                _super_wire_send(msg)
+
         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,
-        )
-        wire = get_wire_or_none()
-        assert wire is not None, "Wire is expected to be set"
-        sub_wire = _SubWire(wire)
+        soul = KimiSoul(agent, runtime=self._runtime, context=context)
 
         try:
-            await soul.run(prompt, sub_wire)
+            await run_soul(soul, prompt, _ui_loop_fn, asyncio.Event())
         except MaxStepsReached as e:
             return ToolError(
                 message=(
@@ -135,22 +155,10 @@ class Task(CallableTool2[Params]):
         # Check if response is too brief, if so, run again with continuation prompt
         n_attempts_remaining = MAX_CONTINUE_ATTEMPTS
         if len(final_response) < 200 and n_attempts_remaining > 0:
-            await soul.run(CONTINUE_PROMPT, sub_wire)
+            await run_soul(soul, CONTINUE_PROMPT, _ui_loop_fn, asyncio.Event())
 
             if len(context.history) == 0 or context.history[-1].role != "assistant":
                 return ToolError(message=_error_msg, brief="Failed to run subagent")
             final_response = message_extract_text(context.history[-1])
 
         return ToolOk(output=final_response)
-
-
-class _SubWire(Wire):
-    def __init__(self, super_wire: Wire):
-        super().__init__()
-        self._super_wire = super_wire
-
-    @override
-    def send(self, msg: WireMessage):
-        if isinstance(msg, ApprovalRequest):
-            self._super_wire.send(msg)
-        # TODO: visualize subagent behavior by sending other messages in some way

kimi_cli/tools/task/task.md

@@ -4,7 +4,7 @@ Spawn a subagent to perform a specific task. Subagent will be spawned with a fre
 
 Context isolation is one of the key benefits of using subagents. By delegating tasks to subagents, you can keep your main context clean and focused on the main goal requested by the user.
 
-Here are some scenerios you may want this tool for context isolation:
+Here are some scenarios you may want this tool for context isolation:
 
 - You wrote some code and it did not work as expected. In this case you can spawn a subagent to fix the code, asking the subagent to return how it is fixed. This can potentially benefit because the detailed process of fixing the code may not be relevant to your main goal, and may clutter your context.
 - When you need some latest knowledge of a specific library, framework or technology to proceed with your task, you can spawn a subagent to search on the internet for the needed information and return to you the gathered relevant information, for example code examples, API references, etc. This can avoid ton of irrelevant search results in your own context.

kimi_cli/tools/todo/__init__.py

@@ -16,7 +16,7 @@ class Params(BaseModel):
 
 class SetTodoList(CallableTool2[Params]):
     name: str = "SetTodoList"
-    description: str = (Path(__file__).parent / "set_todo_list.md").read_text()
+    description: str = (Path(__file__).parent / "set_todo_list.md").read_text(encoding="utf-8")
     params: type[Params] = Params
 
     @override

kimi_cli/tools/utils.py

@@ -7,7 +7,7 @@ from kosong.tooling import ToolError, ToolOk
 
 def load_desc(path: Path, substitutions: dict[str, str] | None = None) -> str:
     """Load a tool description from a file, with optional substitutions."""
-    description = path.read_text()
+    description = path.read_text(encoding="utf-8")
     if substitutions:
         description = string.Template(description).substitute(substitutions)
     return description

kimi_cli/tools/web/search.py

@@ -4,8 +4,8 @@ from typing import override
 from kosong.tooling import CallableTool2, ToolReturnType
 from pydantic import BaseModel, Field, ValidationError
 
-import kimi_cli
 from kimi_cli.config import Config
+from kimi_cli.constant import USER_AGENT
 from kimi_cli.soul.toolset import get_current_tool_call_or_none
 from kimi_cli.tools.utils import ToolResultBuilder, load_desc
 from kimi_cli.utils.aiohttp import new_client_session
@@ -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:
@@ -66,9 +68,10 @@ class SearchWeb(CallableTool2[Params]):
             session.post(
                 self._base_url,
                 headers={
-                    "User-Agent": kimi_cli.USER_AGENT,
+                    "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/__init__.py

@@ -1,69 +0,0 @@
-import asyncio
-import contextlib
-from collections.abc import Callable, Coroutine
-from typing import Any
-
-from kimi_cli.soul import Soul
-from kimi_cli.soul.wire import Wire
-from kimi_cli.utils.logging import logger
-
-type UILoopFn = Callable[[Wire], Coroutine[Any, Any, None]]
-"""A long-running async function to visualize the agent behavior."""
-
-
-class RunCancelled(Exception):
-    """The run was cancelled by the cancel event."""
-
-
-async def run_soul(
-    soul: Soul,
-    user_input: str,
-    ui_loop_fn: UILoopFn,
-    cancel_event: asyncio.Event,
-):
-    """
-    Run the soul with the given user input.
-
-    `cancel_event` is a outside handle that can be used to cancel the run. When the event is set,
-    the run will be gracefully stopped and a `RunCancelled` will be raised.
-
-    Raises:
-        LLMNotSet: When the LLM is not set.
-        ChatProviderError: When the LLM provider returns an error.
-        MaxStepsReached: When the maximum number of steps is reached.
-        RunCancelled: When the run is cancelled by the cancel event.
-    """
-    wire = Wire()
-    logger.debug("Starting UI loop with function: {ui_loop_fn}", ui_loop_fn=ui_loop_fn)
-
-    ui_task = asyncio.create_task(ui_loop_fn(wire))
-    soul_task = asyncio.create_task(soul.run(user_input, wire))
-
-    cancel_event_task = asyncio.create_task(cancel_event.wait())
-    await asyncio.wait(
-        [soul_task, cancel_event_task],
-        return_when=asyncio.FIRST_COMPLETED,
-    )
-
-    try:
-        if cancel_event.is_set():
-            logger.debug("Cancelling the run task")
-            soul_task.cancel()
-            try:
-                await soul_task
-            except asyncio.CancelledError:
-                raise RunCancelled from None
-        else:
-            assert soul_task.done()  # either stop event is set or the run task is done
-            cancel_event_task.cancel()
-            with contextlib.suppress(asyncio.CancelledError):
-                await cancel_event_task
-            soul_task.result()  # this will raise if any exception was raised in the run task
-    finally:
-        logger.debug("Shutting down the visualization loop")
-        # shutting down the event queue should break the visualization loop
-        wire.shutdown()
-        try:
-            await asyncio.wait_for(ui_task, timeout=0.5)
-        except TimeoutError:
-            logger.warning("Visualization loop timed out")

kimi_cli/ui/acp/__init__.py

@@ -12,18 +12,17 @@ from kosong.base.message import (
 from kosong.chat_provider import ChatProviderError
 from kosong.tooling import ToolError, ToolOk, ToolResult
 
-from kimi_cli.soul import LLMNotSet, MaxStepsReached, Soul
-from kimi_cli.soul.wire import (
+from kimi_cli.soul import LLMNotSet, MaxStepsReached, RunCancelled, Soul, run_soul
+from kimi_cli.tools import extract_subtitle
+from kimi_cli.utils.logging import logger
+from kimi_cli.wire import WireUISide
+from kimi_cli.wire.message import (
     ApprovalRequest,
     ApprovalResponse,
     StatusUpdate,
     StepBegin,
     StepInterrupted,
-    Wire,
 )
-from kimi_cli.tools import extract_subtitle
-from kimi_cli.ui import RunCancelled, run_soul
-from kimi_cli.utils.logging import logger
 
 
 class _ToolCallState:
@@ -64,7 +63,7 @@ class _RunState:
         self.cancel_event = asyncio.Event()
 
 
-class ACPAgentImpl:
+class ACPAgent:
     """Implementation of the ACP Agent protocol."""
 
     def __init__(self, soul: Soul, connection: acp.AgentSideConnection):
@@ -172,7 +171,7 @@ class ACPAgentImpl:
             logger.info("Cancelling running prompt")
             self.run_state.cancel_event.set()
 
-    async def _stream_events(self, wire: Wire):
+    async def _stream_events(self, wire: WireUISide):
         try:
             # expect a StepBegin
             assert isinstance(await wire.receive(), StepBegin)
@@ -428,7 +427,7 @@ class ACPServer:
 
         # Create connection - the library handles all JSON-RPC details!
         _ = acp.AgentSideConnection(
-            lambda conn: ACPAgentImpl(self.soul, conn),
+            lambda conn: ACPAgent(self.soul, conn),
             writer,
             reader,
         )

kimi_cli/ui/print/__init__.py

@@ -3,18 +3,18 @@ import json
 import signal
 import sys
 from functools import partial
+from pathlib import Path
 from typing import Literal
 
 import aiofiles
 from kosong.base.message import Message
 from kosong.chat_provider import ChatProviderError
 
-from kimi_cli.soul import LLMNotSet, MaxStepsReached
-from kimi_cli.soul.kimisoul import KimiSoul
-from kimi_cli.soul.wire import StepInterrupted, Wire
-from kimi_cli.ui import RunCancelled, run_soul
+from kimi_cli.soul import LLMNotSet, MaxStepsReached, RunCancelled, Soul, run_soul
 from kimi_cli.utils.logging import logger
 from kimi_cli.utils.message import message_extract_text
+from kimi_cli.wire import WireUISide
+from kimi_cli.wire.message import StepInterrupted
 
 InputFormat = Literal["text", "stream-json"]
 OutputFormat = Literal["text", "stream-json"]
@@ -25,17 +25,23 @@ class PrintApp:
     An app implementation that prints the agent behavior to the console.
 
     Args:
-        soul (KimiSoul): The soul to run. Only `KimiSoul` is supported.
+        soul (Soul): The soul to run.
         input_format (InputFormat): The input format to use.
         output_format (OutputFormat): The output format to use.
+        context_file (Path): The file to store the context.
     """
 
-    def __init__(self, soul: KimiSoul, input_format: InputFormat, output_format: OutputFormat):
+    def __init__(
+        self,
+        soul: Soul,
+        input_format: InputFormat,
+        output_format: OutputFormat,
+        context_file: Path,
+    ):
         self.soul = soul
         self.input_format = input_format
         self.output_format = output_format
-        self.soul._approval.set_yolo(True)
-        # TODO(approval): proper approval request handling
+        self.context_file = context_file
 
     async def run(self, command: str | None = None) -> bool:
         cancel_event = asyncio.Event()
@@ -95,30 +101,6 @@ class PrintApp:
             loop.remove_signal_handler(signal.SIGINT)
         return False
 
-    # TODO: unify with `_soul_run` in `ShellApp` and `ACPAgentImpl`
-    async def _soul_run(self, user_input: str):
-        wire = Wire()
-        logger.debug("Starting visualization loop")
-
-        if self.output_format == "text":
-            vis_task = asyncio.create_task(self._visualize_text(wire))
-        else:
-            assert self.output_format == "stream-json"
-            if not self.soul._context._file_backend.exists():
-                self.soul._context._file_backend.touch()
-            start_position = self.soul._context._file_backend.stat().st_size
-            vis_task = asyncio.create_task(self._visualize_stream_json(wire, start_position))
-
-        try:
-            await self.soul.run(user_input, wire)
-        finally:
-            wire.shutdown()
-            # shutting down the event queue should break the visualization loop
-            try:
-                await asyncio.wait_for(vis_task, timeout=0.5)
-            except TimeoutError:
-                logger.warning("Visualization loop timed out")
-
     def _read_next_command(self) -> str | None:
         while True:
             json_line = sys.stdin.readline()
@@ -144,7 +126,7 @@ class PrintApp:
             except Exception:
                 logger.warning("Ignoring invalid user message: {json_line}", json_line=json_line)
 
-    async def _visualize_text(self, wire: Wire):
+    async def _visualize_text(self, wire: WireUISide):
         try:
             while True:
                 msg = await wire.receive()
@@ -154,15 +136,17 @@ class PrintApp:
         except asyncio.QueueShutDown:
             logger.debug("Visualization loop shutting down")
 
-    async def _visualize_stream_json(self, wire: Wire, start_position: int):
+    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.soul._context._file_backend, encoding="utf-8") as f:
+            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

@@ -9,9 +9,8 @@ from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
 
-from kimi_cli.soul import LLMNotSet, MaxStepsReached, Soul
+from kimi_cli.soul import LLMNotSet, MaxStepsReached, RunCancelled, Soul, run_soul
 from kimi_cli.soul.kimisoul import KimiSoul
-from kimi_cli.ui import RunCancelled, run_soul
 from kimi_cli.ui.shell.console import console
 from kimi_cli.ui.shell.metacmd import get_meta_command
 from kimi_cli.ui.shell.prompt import CustomPromptSession, PromptMode, toast
@@ -20,12 +19,6 @@ from kimi_cli.ui.shell.visualize import visualize
 from kimi_cli.utils.logging import logger
 
 
-class Reload(Exception):
-    """Reload configuration."""
-
-    pass
-
-
 class ShellApp:
     def __init__(self, soul: Soul, welcome_info: dict[str, str] | None = None):
         self.soul = soul
@@ -38,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)
 
@@ -106,6 +99,8 @@ class ShellApp:
             loop.remove_signal_handler(signal.SIGINT)
 
     async def _run_meta_command(self, command_str: str):
+        from kimi_cli.cli import Reload
+
         parts = command_str.split(" ")
         command_name = parts[0]
         command_args = parts[1:]
@@ -188,9 +183,6 @@ class ShellApp:
         except RunCancelled:
             logger.info("Cancelled by user")
             console.print("[red]Interrupted by user[/red]")
-        except Reload:
-            # just propagate
-            raise
         except BaseException as e:
             logger.exception("Unknown error:")
             console.print(f"[red]Unknown error: {e}[/red]")
@@ -199,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:
@@ -212,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)
 
@@ -265,9 +254,9 @@ def _print_welcome_info(name: str, model: str, info_items: dict[str, str]) -> No
         )
 
     if LATEST_VERSION_FILE.exists():
-        from kimi_cli import __version__ as current_version
+        from kimi_cli.constant import VERSION as current_version
 
-        latest_version = LATEST_VERSION_FILE.read_text().strip()
+        latest_version = LATEST_VERSION_FILE.read_text(encoding="utf-8").strip()
         if semver_tuple(latest_version) > semver_tuple(current_version):
             rows.append(
                 Text.from_markup(

kimi_cli/ui/shell/liveview.py

@@ -15,10 +15,10 @@ from rich.status import Status
 from rich.text import Text
 
 from kimi_cli.soul import StatusSnapshot
-from kimi_cli.soul.wire import ApprovalRequest, ApprovalResponse
 from kimi_cli.tools import extract_subtitle
 from kimi_cli.ui.shell.console import console
 from kimi_cli.ui.shell.keyboard import KeyEvent
+from kimi_cli.wire.message import ApprovalRequest, ApprovalResponse
 
 
 class _ToolCallDisplay:

kimi_cli/ui/shell/metacmd.py

@@ -8,10 +8,10 @@ from kosong.base.message import Message
 from rich.panel import Panel
 
 import kimi_cli.prompts as prompts
-from kimi_cli.agent import load_agents_md
 from kimi_cli.soul.context import Context
 from kimi_cli.soul.kimisoul import KimiSoul
 from kimi_cli.soul.message import system
+from kimi_cli.soul.runtime import load_agents_md
 from kimi_cli.ui.shell.console import console
 from kimi_cli.utils.changelog import CHANGELOG, format_release_notes
 from kimi_cli.utils.logging import logger
@@ -173,9 +173,9 @@ def help(app: "ShellApp", args: list[str]):
 @meta_command
 def version(app: "ShellApp", args: list[str]):
     """Show version information"""
-    from kimi_cli import __version__
+    from kimi_cli.constant import VERSION
 
-    console.print(f"kimi, version {__version__}")
+    console.print(f"kimi, version {VERSION}")
 
 
 @meta_command(name="release-notes")
@@ -206,12 +206,7 @@ async def init(app: "ShellApp", args: list[str]):
         logger.info("Running `/init`")
         console.print("Analyzing the codebase...")
         tmp_context = Context(file_backend=Path(temp_dir) / "context.jsonl")
-        app.soul = KimiSoul(
-            soul_bak._agent,
-            soul_bak._agent_globals,
-            context=tmp_context,
-            loop_control=soul_bak._loop_control,
-        )
+        app.soul = KimiSoul(soul_bak._agent, soul_bak._runtime, context=tmp_context)
         ok = await app._run_soul_command(prompts.INIT)
 
         if ok:
@@ -223,7 +218,7 @@ async def init(app: "ShellApp", args: list[str]):
             console.print("[red]Failed to analyze the codebase.[/red]")
 
     app.soul = soul_bak
-    agents_md = load_agents_md(soul_bak._agent_globals.builtin_args.KIMI_WORK_DIR)
+    agents_md = load_agents_md(soul_bak._runtime.builtin_args.KIMI_WORK_DIR)
     system_message = system(
         "The user just ran `/init` meta command. "
         "The system has analyzed the codebase and generated an `AGENTS.md` file. "