kimi-cli 0.44__py3-none-any.whl → 0.78__py3-none-any.whl

kimi_cli/agents/default/system.md

@@ -1,34 +1,33 @@
-You are Kimi CLI. You are an interactive CLI agent specializing in software engineering tasks. Your primary goal is to help users safely and efficiently, adhering strictly to the following instructions and utilizing your available tools.
+You are Kimi CLI, an interactive general AI agent running on a user's computer.
+
+Your primary goal is to answer questions and/or finish tasks safely and efficiently, adhering strictly to the following system instructions and the user's requirements, leveraging the available tools flexibly.
 
 ${ROLE_ADDITIONAL}
 
 # Prompt and Tool Use
 
-The user's requests are provided in natural language within `user` messages, which may contain code snippets, logs, file paths, or specific requirements. ALWAYS follow the user's requests, always stay on track. Do not do anything that is not asked.
+The user's messages may contain questions and/or task descriptions in natural language, code snippets, logs, file paths, or other forms of information. Read them, understand them and do what the user requested. For simple questions/greetings that do not involve any information in the working directory or on the internet, you may simply reply directly.
 
-When handling the user's request, you can call available tools to accomplish the task. When calling tools, do not provide explanations because the tool calls themselves should be self-explanatory. You MUST follow the description of each tool and its parameters when calling tools.
+When handling the user's request, you may call available tools to accomplish the task. When calling tools, do not provide explanations because the tool calls themselves should be self-explanatory. You MUST follow the description of each tool and its parameters when calling tools.
 
 You have the capability to output any number of tool calls in a single response. If you anticipate making multiple non-interfering tool calls, you are HIGHLY RECOMMENDED to make them in parallel to significantly improve efficiency. This is very important to your performance.
 
-The results of the tool calls will be returned to you in a `tool` message. In some cases, non-plain-text content might be sent as a `user` message following the `tool` message. You must decide on your next action based on the tool call results, which could be one of the following: 1. Continue working on the task, 2. Inform the user that the task is completed or has failed, or 3. Ask the user for more information.
+The results of the tool calls will be returned to you in a tool message. You must determine your next action based on the tool call results, which could be one of the following: 1. Continue working on the task, 2. Inform the user that the task is completed or has failed, or 3. Ask the user for more information.
 
-The system may, where appropriate, insert hints or information wrapped in `<system>` and `</system>` tags within `user` or `tool` messages. This information is relevant to the current task or tool calls, may or may not be important to you. Take this info into consideration when determining your next action.
+The system may, where appropriate, insert hints or information wrapped in `<system>` and `</system>` tags within user or tool messages. This information is relevant to the current task or tool calls, may or may not be important to you. Take this info into consideration when determining your next action.
 
 When responding to the user, you MUST use the SAME language as the user, unless explicitly instructed to do otherwise.
 
-# General Coding Guidelines
-
-Always think carefully. Be patient and thorough. Do not give up too early.
-
-ALWAYS, keep it stupidly simple. Do not overcomplicate things.
+# General Guidelines for Coding
 
 When building something from scratch, you should:
 
 - Understand the user's requirements.
+- Clarify with the user if there is anything unclear.
 - Design the architecture and make a plan for the implementation.
 - Write the code in a modular and maintainable way.
 
-When working on existing codebase, you should:
+When working on an existing codebase, you should:
 
 - Understand the codebase and the user's requirements. Identify the ultimate goal and the most important criteria to achieve the goal.
 - For a bug fix, you typically need to check error logs or failed tests, scan over the codebase to find the root cause, and figure out a fix. If user mentioned any failed tests, you should make sure they pass after the changes.
@@ -37,15 +36,32 @@ When working on existing codebase, you should:
 - Make MINIMAL changes to achieve the goal. This is very important to your performance.
 - Follow the coding style of existing code in the project.
 
+DO NOT run `git commit`, `git push`, `git reset`, `git rebase` and/or do any other git mutations unless explicitly asked to do so. Ask for confirmation each time when you need to do git mutations, even if the user has confirmed in earlier conversations.
+
+# General Guidelines for Research and Data Processing
+
+The user may ask you to research on certain topics, or process certain multimedia files or folders. You must understand the user's requirements thoroughly, ask for clarification before you start if needed.
+
+Make plans before you do deep or wide research tasks, to ensure you are always on track. Search on the Internet if possible, with carefully-designed search queries to improve efficiency and accuracy.
+
+Operate on the user's computer carefully:
+
+- When working on images, videos, PDFs, docs, spreadsheets, presentations, or other multimedia files, you may need to use proper shell commands or Python tools to process them. Detect if there are already such tools in the environment. If you have to install them, you MUST ensure that any third-party packages are installed in a virtual environment.
+- Avoid installing or deleting anything to/from outside of the current working directory. If you have to do so, ask the user for confirmation.
+
 # Working Environment
 
 ## Operating System
 
-The operating environment is not in a sandbox. Any action especially mutation you do will immediately affect the user's system. So you MUST be extremely cautious. Unless being explicitly instructed to do so, you should never access (read/write/execute) files outside of the working directory.
+The operating environment is not in a sandbox. Any actions you do will immediately affect the user's system. So you MUST be extremely cautious. Unless being explicitly instructed to do so, you should never access (read/write/execute) files outside of the working directory.
+
+## Date and Time
+
+The current date and time in ISO format is `${KIMI_NOW}`. This is only a reference for you when searching the web, or checking file modification time, etc. If you need the exact time, use Shell tool with proper command.
 
 ## Working Directory
 
-The current working directory is `${KIMI_WORK_DIR}`. This should be considered as the project root if you are instructed to perform tasks on the project. Every file system operation will be relative to the working directory if you do not explicitly specify the absolute path. Tools may require absolute paths for some parameters, if so, you should strictly follow the requirements.
+The current working directory is `${KIMI_WORK_DIR}`. This should be considered as the project root if you are instructed to perform tasks on the project. Every file system operation will be relative to the working directory if you do not explicitly specify the absolute path. Tools may require absolute paths for some parameters, IF SO, YOU MUST use absolute paths for these parameters.
 
 The directory listing of current working directory is:
 
@@ -55,18 +71,60 @@ ${KIMI_WORK_DIR_LS}
 
 Use this as your basic understanding of the project structure.
 
-## Date and Time
-
-The current date and time in ISO format is `${KIMI_NOW}`. This is only a reference for you when searching the web, or checking file modification time, etc. If you need the exact time, use Bash tool with proper command.
-
 # Project Information
 
-Markdown files named `AGENTS.md` usually contain the background, structure, coding styles, user preferences and other relevant information about the project. You should use this information to understand the project and the user's preferences. `AGENTS.md` files may exist at different locations in the project, but typically there is one in the project root. The following content between two `---`s is the content of the root-level `AGENTS.md` file.
+Markdown files named `AGENTS.md` usually contain the background, structure, coding styles, user preferences and other relevant information about the project. You should use this information to understand the project and the user's preferences. `AGENTS.md` files may exist at different locations in the project, but typically there is one in the project root.
 
-`${KIMI_WORK_DIR}/AGENTS.md`:
+> Why `AGENTS.md`?
+>
+> `README.md` files are for humans: quick starts, project descriptions, and contribution guidelines. `AGENTS.md` complements this by containing the extra, sometimes detailed context coding agents need: build steps, tests, and conventions that might clutter a README or aren’t relevant to human contributors.
+>
+> We intentionally kept it separate to:
+>
+> - Give agents a clear, predictable place for instructions.
+> - Keep `README`s concise and focused on human contributors.
+> - Provide precise, agent-focused guidance that complements existing `README` and docs.
 
----
+The project level `${KIMI_WORK_DIR}/AGENTS.md`:
 
+`````````
 ${KIMI_AGENTS_MD}
+`````````
+
+If the above `AGENTS.md` is empty or insufficient, you may check `README`/`README.md` files or `AGENTS.md` files in subdirectories for more information about specific parts of the project.
+
+If you modified any files/styles/structures/configurations/workflows/... mentioned in `AGENTS.md` files, you MUST update the corresponding `AGENTS.md` files to keep them up-to-date.
+
+# Skills
+
+Skills are reusable, composable capabilities that enhance your abilities. Each skill is a self-contained directory with a `SKILL.md` file that contains instructions, examples, and/or reference material.
+
+## What are skills?
+
+Skills are modular extensions that provide:
+
+- Specialized knowledge: Domain-specific expertise (e.g., PDF processing, data analysis)
+- Workflow patterns: Best practices for common tasks
+- Tool integrations: Pre-configured tool chains for specific operations
+- Reference material: Documentation, templates, and examples
+
+## Available skills
+
+${KIMI_SKILLS}
+
+## How to use skills
+
+Identify the skills that are likely to be useful for the tasks you are currently working on, read the `SKILL.md` file for detailed instructions, guidelines, scripts and more.
+
+Only read skill details when needed to conserve the context window.
+
+# Ultimate Reminders
+
+At any time, you should be HELPFUL and POLITE, CONCISE and ACCURATE, PATIENT and THOROUGH.
 
----
+- Never diverge from the requirements and the goals of the task you work on. Stay on track.
+- Never give the user more than what they want.
+- Try your best to avoid any hallucination. Do fact checking before providing any factual information.
+- Think twice before you act.
+- Do not give up too early.
+- ALWAYS, keep it stupidly simple. Do not overcomplicate things.

kimi_cli/agents/okabe/agent.yaml

@@ -0,0 +1,17 @@
+version: 1
+agent:
+  extend: default
+  tools:
+    - "kimi_cli.tools.multiagent:Task"
+    # - "kimi_cli.tools.multiagent:CreateSubagent"
+    - "kimi_cli.tools.dmail:SendDMail"
+    # - "kimi_cli.tools.think:Think"
+    - "kimi_cli.tools.todo:SetTodoList"
+    - "kimi_cli.tools.shell:Shell"
+    - "kimi_cli.tools.file:ReadFile"
+    - "kimi_cli.tools.file:Glob"
+    - "kimi_cli.tools.file:Grep"
+    - "kimi_cli.tools.file:WriteFile"
+    - "kimi_cli.tools.file:StrReplaceFile"
+    - "kimi_cli.tools.web:SearchWeb"
+    - "kimi_cli.tools.web:FetchURL"

kimi_cli/agentspec.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, NamedTuple
 
@@ -6,28 +9,43 @@ from pydantic import BaseModel, Field
 
 from kimi_cli.exception import AgentSpecError
 
+DEFAULT_AGENT_SPEC_VERSION = "1"
+SUPPORTED_AGENT_SPEC_VERSIONS = (DEFAULT_AGENT_SPEC_VERSION,)
+
 
 def get_agents_dir() -> Path:
     return Path(__file__).parent / "agents"
 
 
 DEFAULT_AGENT_FILE = get_agents_dir() / "default" / "agent.yaml"
+OKABE_AGENT_FILE = get_agents_dir() / "okabe" / "agent.yaml"
+
+
+class Inherit(NamedTuple):
+    """Marker class for inheritance in agent spec."""
+
+
+inherit = Inherit()
 
 
 class AgentSpec(BaseModel):
     """Agent specification."""
 
     extend: str | None = Field(default=None, description="Agent file to extend")
-    name: str | None = Field(default=None, description="Agent name")  # required
-    system_prompt_path: Path | None = Field(
-        default=None, description="System prompt path"
+    name: str | Inherit = Field(default=inherit, description="Agent name")  # required
+    system_prompt_path: Path | Inherit = Field(
+        default=inherit, description="System prompt path"
     )  # required
     system_prompt_args: dict[str, str] = Field(
         default_factory=dict, description="System prompt arguments"
     )
-    tools: list[str] | None = Field(default=None, description="Tools")  # required
-    exclude_tools: list[str] | None = Field(default=None, description="Tools to exclude")
-    subagents: dict[str, "SubagentSpec"] | None = Field(default=None, description="Subagents")
+    tools: list[str] | None | Inherit = Field(default=inherit, description="Tools")  # required
+    exclude_tools: list[str] | None | Inherit = Field(
+        default=inherit, description="Tools to exclude"
+    )
+    subagents: dict[str, SubagentSpec] | None | Inherit = Field(
+        default=inherit, description="Subagents"
+    )
 
 
 class SubagentSpec(BaseModel):
@@ -37,7 +55,8 @@ class SubagentSpec(BaseModel):
     description: str = Field(description="Subagent description")
 
 
-class ResolvedAgentSpec(NamedTuple):
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ResolvedAgentSpec:
     """Resolved agent specification."""
 
     name: str
@@ -45,7 +64,7 @@ class ResolvedAgentSpec(NamedTuple):
     system_prompt_args: dict[str, str]
     tools: list[str]
     exclude_tools: list[str]
-    subagents: dict[str, "SubagentSpec"]
+    subagents: dict[str, SubagentSpec]
 
 
 def load_agent_spec(agent_file: Path) -> ResolvedAgentSpec:
@@ -58,58 +77,67 @@ def load_agent_spec(agent_file: Path) -> ResolvedAgentSpec:
     """
     agent_spec = _load_agent_spec(agent_file)
     assert agent_spec.extend is None, "agent extension should be recursively resolved"
-    if agent_spec.name is None:
+    if isinstance(agent_spec.name, Inherit):
         raise AgentSpecError("Agent name is required")
-    if agent_spec.system_prompt_path is None:
+    if isinstance(agent_spec.system_prompt_path, Inherit):
         raise AgentSpecError("System prompt path is required")
-    if agent_spec.tools is None:
+    if isinstance(agent_spec.tools, Inherit):
         raise AgentSpecError("Tools are required")
+    if isinstance(agent_spec.exclude_tools, Inherit):
+        agent_spec.exclude_tools = []
+    if isinstance(agent_spec.subagents, Inherit):
+        agent_spec.subagents = {}
     return ResolvedAgentSpec(
         name=agent_spec.name,
         system_prompt_path=agent_spec.system_prompt_path,
         system_prompt_args=agent_spec.system_prompt_args,
-        tools=agent_spec.tools,
+        tools=agent_spec.tools or [],
         exclude_tools=agent_spec.exclude_tools or [],
         subagents=agent_spec.subagents or {},
     )
 
 
 def _load_agent_spec(agent_file: Path) -> AgentSpec:
-    assert agent_file.is_file(), "expect agent file to exist"
+    if not agent_file.exists():
+        raise AgentSpecError(f"Agent spec file not found: {agent_file}")
+    if not agent_file.is_file():
+        raise AgentSpecError(f"Agent spec path is not a file: {agent_file}")
     try:
         with open(agent_file, encoding="utf-8") as f:
             data: dict[str, Any] = yaml.safe_load(f)
     except yaml.YAMLError as e:
         raise AgentSpecError(f"Invalid YAML in agent spec file: {e}") from e
 
-    version = data.get("version", 1)
-    if version != 1:
+    version = str(data.get("version", DEFAULT_AGENT_SPEC_VERSION))
+    if version not in SUPPORTED_AGENT_SPEC_VERSIONS:
         raise AgentSpecError(f"Unsupported agent spec version: {version}")
 
     agent_spec = AgentSpec(**data.get("agent", {}))
-    if agent_spec.system_prompt_path is not None:
-        agent_spec.system_prompt_path = agent_file.parent / agent_spec.system_prompt_path
-    if agent_spec.subagents is not None:
+    if isinstance(agent_spec.system_prompt_path, Path):
+        agent_spec.system_prompt_path = (
+            agent_file.parent / agent_spec.system_prompt_path
+        ).absolute()
+    if isinstance(agent_spec.subagents, dict):
         for v in agent_spec.subagents.values():
-            v.path = agent_file.parent / v.path
+            v.path = (agent_file.parent / v.path).absolute()
     if agent_spec.extend:
         if agent_spec.extend == "default":
             base_agent_file = DEFAULT_AGENT_FILE
         else:
-            base_agent_file = agent_file.parent / agent_spec.extend
+            base_agent_file = (agent_file.parent / agent_spec.extend).absolute()
         base_agent_spec = _load_agent_spec(base_agent_file)
-        if agent_spec.name is not None:
+        if not isinstance(agent_spec.name, Inherit):
             base_agent_spec.name = agent_spec.name
-        if agent_spec.system_prompt_path is not None:
+        if not isinstance(agent_spec.system_prompt_path, Inherit):
             base_agent_spec.system_prompt_path = agent_spec.system_prompt_path
         for k, v in agent_spec.system_prompt_args.items():
             # system prompt args should be merged instead of overwritten
             base_agent_spec.system_prompt_args[k] = v
-        if agent_spec.tools is not None:
+        if not isinstance(agent_spec.tools, Inherit):
             base_agent_spec.tools = agent_spec.tools
-        if agent_spec.exclude_tools is not None:
+        if not isinstance(agent_spec.exclude_tools, Inherit):
             base_agent_spec.exclude_tools = agent_spec.exclude_tools
-        if agent_spec.subagents is not None:
+        if not isinstance(agent_spec.subagents, Inherit):
             base_agent_spec.subagents = agent_spec.subagents
         agent_spec = base_agent_spec
     return agent_spec

kimi_cli/app.py

@@ -1,22 +1,49 @@
+from __future__ import annotations
+
+import asyncio
 import contextlib
-import os
 import warnings
-from collections.abc import Generator
+from collections.abc import AsyncGenerator
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
+import kaos
+from kaos.path import KaosPath
 from pydantic import SecretStr
 
 from kimi_cli.agentspec import DEFAULT_AGENT_FILE
 from kimi_cli.cli import InputFormat, OutputFormat
-from kimi_cli.config import LLMModel, LLMProvider, load_config
+from kimi_cli.config import Config, LLMModel, LLMProvider, load_config
+from kimi_cli.flow import PromptFlow
 from kimi_cli.llm import augment_provider_with_env_vars, create_llm
 from kimi_cli.session import Session
-from kimi_cli.soul.agent import load_agent
+from kimi_cli.share import get_share_dir
+from kimi_cli.soul import run_soul
+from kimi_cli.soul.agent import Runtime, load_agent
 from kimi_cli.soul.context import Context
 from kimi_cli.soul.kimisoul import KimiSoul
-from kimi_cli.soul.runtime import Runtime
+from kimi_cli.utils.aioqueue import QueueShutDown
 from kimi_cli.utils.logging import StreamToLogger, logger
+from kimi_cli.utils.path import shorten_home
+from kimi_cli.wire import Wire, WireUISide
+from kimi_cli.wire.types import ContentPart, WireMessage
+
+if TYPE_CHECKING:
+    from fastmcp.mcp_config import MCPConfig
+
+
+def enable_logging(debug: bool = False) -> None:
+    logger.remove()  # Remove default stderr handler
+    logger.enable("kimi_cli")
+    if debug:
+        logger.enable("kosong")
+    logger.add(
+        get_share_dir() / "logs" / "kimi.log",
+        # FIXME: configure level for different modules
+        level="TRACE" if debug else "INFO",
+        rotation="06:00",
+        retention="10 days",
+    )
 
 
 class KimiCLI:
@@ -24,30 +51,60 @@ class KimiCLI:
     async def create(
         session: Session,
         *,
-        yolo: bool = False,
-        stream: bool = True,  # TODO: remove this when we have a correct print mode impl
-        mcp_configs: list[dict[str, Any]] | None = None,
-        config_file: Path | None = None,
+        # Basic configuration
+        config: Config | Path | None = None,
         model_name: str | None = None,
+        thinking: bool | None = None,
+        # Run mode
+        yolo: bool = False,
+        # Extensions
         agent_file: Path | None = None,
-    ) -> "KimiCLI":
+        mcp_configs: list[MCPConfig] | list[dict[str, Any]] | None = None,
+        skills_dir: Path | None = None,
+        # Loop control
+        max_steps_per_turn: int | None = None,
+        max_retries_per_step: int | None = None,
+        max_ralph_iterations: int | None = None,
+        flow: PromptFlow | None = None,
+    ) -> KimiCLI:
         """
         Create a KimiCLI instance.
 
         Args:
             session (Session): A session created by `Session.create` or `Session.continue_`.
-            yolo (bool, optional): Approve all actions without confirmation. Defaults to False.
-            stream (bool, optional): Use stream mode when calling LLM API. Defaults to True.
-            config_file (Path | None, optional): Path to the configuration file. Defaults to None.
+            config (Config | Path | None, optional): Configuration to use, or path to config file.
+                Defaults to None.
             model_name (str | None, optional): Name of the model to use. Defaults to None.
+            thinking (bool | None, optional): Whether to enable thinking mode. Defaults to None.
+            yolo (bool, optional): Approve all actions without confirmation. Defaults to False.
             agent_file (Path | None, optional): Path to the agent file. Defaults to None.
+            mcp_configs (list[MCPConfig | dict[str, Any]] | None, optional): MCP configs to load
+                MCP tools from. Defaults to None.
+            skills_dir (Path | None, optional): Path to the skills directory. Defaults to None.
+            max_steps_per_turn (int | None, optional): Maximum number of steps in one turn.
+                Defaults to None.
+            max_retries_per_step (int | None, optional): Maximum number of retries in one step.
+                Defaults to None.
+            max_ralph_iterations (int | None, optional): Extra iterations after the first turn in
+                Ralph mode. Defaults to None.
+            flow (PromptFlow | None, optional): Prompt flow to execute. Defaults to None.
 
         Raises:
             FileNotFoundError: When the agent file is not found.
-            ConfigError(KimiCLIException): When the configuration is invalid.
-            AgentSpecError(KimiCLIException): When the agent specification is invalid.
+            ConfigError(KimiCLIException, ValueError): When the configuration is invalid.
+            AgentSpecError(KimiCLIException, ValueError): When the agent specification is invalid.
+            InvalidToolError(KimiCLIException, ValueError): When any tool cannot be loaded.
+            MCPConfigError(KimiCLIException, ValueError): When any MCP configuration is invalid.
+            MCPRuntimeError(KimiCLIException, RuntimeError): When any MCP server cannot be
+                connected.
         """
-        config = load_config(config_file)
+        config = config if isinstance(config, Config) else load_config(config)
+        if max_steps_per_turn is not None:
+            config.loop_control.max_steps_per_turn = max_steps_per_turn
+        if max_retries_per_step is not None:
+            config.loop_control.max_retries_per_step = max_retries_per_step
+        if max_ralph_iterations is not None:
+            config.loop_control.max_ralph_iterations = max_ralph_iterations
         logger.info("Loaded config: {config}", config=config)
 
         model: LLMModel | None = None
@@ -72,27 +129,25 @@ class KimiCLI:
         assert model is not None
         env_overrides = augment_provider_with_env_vars(provider, model)
 
-        if not provider.base_url or not model.model:
-            llm = None
-        else:
+        # determine thinking mode
+        thinking = config.default_thinking if thinking is None else thinking
+
+        llm = create_llm(provider, model, thinking=thinking, session_id=session.id)
+        if llm is not None:
             logger.info("Using LLM provider: {provider}", provider=provider)
             logger.info("Using LLM model: {model}", model=model)
-            llm = create_llm(provider, model, stream=stream, session_id=session.id)
+            logger.info("Thinking mode: {thinking}", thinking=thinking)
 
-        runtime = await Runtime.create(config, llm, session, yolo)
+        runtime = await Runtime.create(config, llm, session, yolo, skills_dir)
 
         if agent_file is None:
             agent_file = DEFAULT_AGENT_FILE
         agent = await load_agent(agent_file, runtime, mcp_configs=mcp_configs or [])
 
-        context = Context(session.history_file)
+        context = Context(session.context_file)
         await context.restore()
 
-        soul = KimiSoul(
-            agent,
-            runtime,
-            context=context,
-        )
+        soul = KimiSoul(agent, context=context, flow=flow)
         return KimiCLI(soul, runtime, env_overrides)
 
     def __init__(
@@ -115,23 +170,75 @@ class KimiCLI:
         """Get the Session instance."""
         return self._runtime.session
 
-    @contextlib.contextmanager
-    def _app_env(self) -> Generator[None]:
-        original_cwd = Path.cwd()
-        os.chdir(self._runtime.session.work_dir)
+    @contextlib.asynccontextmanager
+    async def _env(self) -> AsyncGenerator[None]:
+        original_cwd = KaosPath.cwd()
+        await kaos.chdir(self._runtime.session.work_dir)
         try:
             # to ignore possible warnings from dateparser
             warnings.filterwarnings("ignore", category=DeprecationWarning)
             with contextlib.redirect_stderr(StreamToLogger()):
                 yield
         finally:
-            os.chdir(original_cwd)
+            await kaos.chdir(original_cwd)
+
+    async def run(
+        self,
+        user_input: str | list[ContentPart],
+        cancel_event: asyncio.Event,
+        merge_wire_messages: bool = False,
+    ) -> AsyncGenerator[WireMessage]:
+        """
+        Run the Kimi CLI instance without any UI and yield Wire messages directly.
+
+        Args:
+            user_input (str | list[ContentPart]): The user input to the agent.
+            cancel_event (asyncio.Event): An event to cancel the run.
+            merge_wire_messages (bool): Whether to merge Wire messages as much as possible.
 
-    async def run_shell_mode(self, command: str | None = None) -> bool:
-        from kimi_cli.ui.shell import ShellApp, WelcomeInfoItem
+        Yields:
+            WireMessage: The Wire messages from the `KimiSoul`.
+
+        Raises:
+            LLMNotSet: When the LLM is not set.
+            LLMNotSupported: When the LLM does not have required capabilities.
+            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.
+        """
+        async with self._env():
+            wire_future = asyncio.Future[WireUISide]()
+            stop_ui_loop = asyncio.Event()
+
+            async def _ui_loop_fn(wire: Wire) -> None:
+                wire_future.set_result(wire.ui_side(merge=merge_wire_messages))
+                await stop_ui_loop.wait()
+
+            soul_task = asyncio.create_task(
+                run_soul(self.soul, user_input, _ui_loop_fn, cancel_event)
+            )
+
+            try:
+                wire_ui = await wire_future
+                while True:
+                    msg = await wire_ui.receive()
+                    yield msg
+            except QueueShutDown:
+                pass
+            finally:
+                # stop consuming Wire messages
+                stop_ui_loop.set()
+                # wait for the soul task to finish, or raise
+                await soul_task
+
+    async def run_shell(self, command: str | None = None) -> bool:
+        """Run the Kimi CLI instance with shell UI."""
+        from kimi_cli.ui.shell import Shell, WelcomeInfoItem
 
         welcome_info = [
-            WelcomeInfoItem(name="Directory", value=str(self._runtime.session.work_dir)),
+            WelcomeInfoItem(
+                name="Directory", value=str(shorten_home(self._runtime.session.work_dir))
+            ),
             WelcomeInfoItem(name="Session", value=self._runtime.session.id),
         ]
         if base_url := self._env_overrides.get("KIMI_BASE_URL"):
@@ -142,6 +249,14 @@ class KimiCLI:
                     level=WelcomeInfoItem.Level.WARN,
                 )
             )
+        if self._env_overrides.get("KIMI_API_KEY"):
+            welcome_info.append(
+                WelcomeInfoItem(
+                    name="API Key",
+                    value="****** (from KIMI_API_KEY)",
+                    level=WelcomeInfoItem.Level.WARN,
+                )
+            )
         if not self._runtime.llm:
             welcome_info.append(
                 WelcomeInfoItem(
@@ -154,7 +269,7 @@ class KimiCLI:
             welcome_info.append(
                 WelcomeInfoItem(
                     name="Model",
-                    value=f"{self._soul.model} (from KIMI_MODEL_NAME)",
+                    value=f"{self._soul.model_name} (from KIMI_MODEL_NAME)",
                     level=WelcomeInfoItem.Level.WARN,
                 )
             )
@@ -162,34 +277,47 @@ class KimiCLI:
             welcome_info.append(
                 WelcomeInfoItem(
                     name="Model",
-                    value=self._soul.model,
+                    value=self._soul.model_name,
                     level=WelcomeInfoItem.Level.INFO,
                 )
             )
-        with self._app_env():
-            app = ShellApp(self._soul, welcome_info=welcome_info)
-            return await app.run(command)
+        async with self._env():
+            shell = Shell(self._soul, welcome_info=welcome_info)
+            return await shell.run(command)
 
-    async def run_print_mode(
+    async def run_print(
         self,
         input_format: InputFormat,
         output_format: OutputFormat,
         command: str | None = None,
+        *,
+        final_only: bool = False,
     ) -> bool:
-        from kimi_cli.ui.print import PrintApp
+        """Run the Kimi CLI instance with print UI."""
+        from kimi_cli.ui.print import Print
 
-        with self._app_env():
-            app = PrintApp(
+        async with self._env():
+            print_ = Print(
                 self._soul,
                 input_format,
                 output_format,
-                self._runtime.session.history_file,
+                self._runtime.session.context_file,
+                final_only=final_only,
             )
-            return await app.run(command)
+            return await print_.run(command)
+
+    async def run_acp(self) -> None:
+        """Run the Kimi CLI instance as ACP server."""
+        from kimi_cli.ui.acp import ACP
+
+        async with self._env():
+            acp = ACP(self._soul)
+            await acp.run()
 
-    async def run_acp_server(self) -> bool:
-        from kimi_cli.ui.acp import ACPServer
+    async def run_wire_stdio(self) -> None:
+        """Run the Kimi CLI instance as Wire server over stdio."""
+        from kimi_cli.ui.wire import WireOverStdio
 
-        with self._app_env():
-            app = ACPServer(self._soul)
-            return await app.run()
+        async with self._env():
+            server = WireOverStdio(self._soul)
+            await server.serve()