kimi-cli 0.35__py3-none-any.whl → 0.37__py3-none-any.whl

kimi_cli/CHANGELOG.md

@@ -9,6 +9,26 @@ Internal builds may append content to the Unreleased section.
 Only write entries that are worth mentioning to users.
 -->
 
+## [0.37] - 2025-10-24
+
+### Fixed
+
+- Fix update checking
+
+## [0.36] - 2025-10-24
+
+### Added
+
+- Add `/debug` meta command to debug the context
+- Add auto context compaction
+- Add approval request mechanism
+- Add `--yolo` option to automatically approve all actions
+- Render markdown content for better readability
+
+### Fixed
+
+- Fix "unknown error" message when interrupting a meta command
+
 ## [0.35] - 2025-10-22
 
 ### Changed

kimi_cli/__init__.py

@@ -152,6 +152,16 @@ UIMode = Literal["shell", "print", "acp"]
         "Default: none."
     ),
 )
+@click.option(
+    "--yolo",
+    "--yes",
+    "-y",
+    "--auto-approve",
+    "yolo",
+    is_flag=True,
+    default=False,
+    help="Automatically approve all actions. Default: no.",
+)
 def kimi(
     verbose: bool,
     debug: bool,
@@ -165,6 +175,7 @@ def kimi(
     output_format: OutputFormat | None,
     mcp_config_file: list[Path],
     mcp_config: list[str],
+    yolo: bool,
 ):
     """Kimi, your next CLI agent."""
     echo = click.echo if verbose else lambda *args, **kwargs: None
@@ -232,6 +243,7 @@ def kimi(
                     input_format=input_format,
                     output_format=output_format,
                     mcp_configs=mcp_configs,
+                    yolo=yolo,
                 )
             )
             if not succeeded:
@@ -254,6 +266,7 @@ async def kimi_run(
     input_format: InputFormat | None = None,
     output_format: OutputFormat | None = None,
     mcp_configs: list[dict[str, Any]] | None = None,
+    yolo: bool = False,
 ) -> bool:
     """Run Kimi CLI."""
     echo = click.echo if verbose else lambda *args, **kwargs: None
@@ -286,7 +299,7 @@ async def kimi_run(
         echo(f"✓ Using LLM provider: {provider}")
         echo(f"✓ Using LLM model: {model}")
         stream = ui != "print"  # use non-streaming mode only for print UI
-        llm = create_llm(provider, model, stream=stream)
+        llm = create_llm(provider, model, stream=stream, session_id=session.id)
 
     # TODO: support Windows
     ls = subprocess.run(["ls", "-la"], capture_output=True, text=True)
@@ -305,7 +318,7 @@ async def kimi_run(
         ),
         denwa_renji=DenwaRenji(),
         session=session,
-        approval=Approval(),
+        approval=Approval(yolo=yolo),
     )
     try:
         agent = await load_agent_with_mcp(agent_file, agent_globals, mcp_configs or [])

kimi_cli/soul/__init__.py

@@ -51,7 +51,7 @@ class Soul(Protocol):
             wire (Wire): The wire to send events and requests to the UI loop.
 
         Raises:
-            ChatProviderNotSet: When the chat provider is not set.
+            LLMNotSet: When the LLM is not set.
             ChatProviderError: When the LLM provider returns an error.
             MaxStepsReached: When the maximum number of steps is reached.
             asyncio.CancelledError: When the run is cancelled by user.

kimi_cli/soul/approval.py

@@ -15,11 +15,12 @@ class Approval:
     def set_yolo(self, yolo: bool) -> None:
         self._yolo = yolo
 
-    async def request(self, action: str, description: str) -> bool:
+    async def request(self, sender: str, action: str, description: str) -> bool:
         """
         Request approval for the given action. Intended to be called by tools.
 
         Args:
+            sender (str): The name of the sender.
             action (str): The action to request approval for.
                 This is used to identify the action for auto-approval.
             description (str): The description of the action. This is used to display to the user.
@@ -47,7 +48,7 @@ class Approval:
         if action in self._auto_approve_actions:
             return True
 
-        request = ApprovalRequest(tool_call.id, action, description)
+        request = ApprovalRequest(tool_call.id, sender, action, description)
         self._request_queue.put_nowait(request)
         response = await request.wait()
         logger.debug("Received approval response: {response}", response=response)

kimi_cli/soul/compaction.py

@@ -0,0 +1,105 @@
+from collections.abc import Sequence
+from string import Template
+from typing import Protocol, runtime_checkable
+
+from kosong.base import generate
+from kosong.base.message import ContentPart, Message, TextPart
+
+import kimi_cli.prompts as prompts
+from kimi_cli.llm import LLM
+from kimi_cli.soul.message import system
+from kimi_cli.utils.logging import logger
+
+MAX_PRESERVED_MESSAGES = 2
+
+
+@runtime_checkable
+class Compaction(Protocol):
+    async def compact(self, messages: Sequence[Message], llm: LLM) -> Sequence[Message]:
+        """
+        Compact a sequence of messages into a new sequence of messages.
+
+        Args:
+            messages (Sequence[Message]): The messages to compact.
+            llm (LLM): The LLM to use for compaction.
+
+        Returns:
+            Sequence[Message]: The compacted messages.
+
+        Raises:
+            ChatProviderError: When the chat provider returns an error.
+        """
+        ...
+
+
+class SimpleCompaction:
+    async def compact(self, messages: Sequence[Message], llm: LLM) -> Sequence[Message]:
+        history = list(messages)
+        if not history:
+            return history
+
+        preserve_start_index = len(history)
+        n_preserved = 0
+        for index in range(len(history) - 1, -1, -1):
+            if history[index].role in {"user", "assistant"}:
+                n_preserved += 1
+                if n_preserved == MAX_PRESERVED_MESSAGES:
+                    preserve_start_index = index
+                    break
+
+        if n_preserved < MAX_PRESERVED_MESSAGES:
+            return history
+
+        to_compact = history[:preserve_start_index]
+        to_preserve = history[preserve_start_index:]
+
+        if not to_compact:
+            # Let's hope this won't exceed the context size limit
+            return to_preserve
+
+        # Convert history to string for the compact prompt
+        history_text = "\n\n".join(
+            f"## Message {i + 1}\nRole: {msg.role}\nContent: {msg.content}"
+            for i, msg in enumerate(to_compact)
+        )
+
+        # Build the compact prompt using string template
+        compact_template = Template(prompts.COMPACT)
+        compact_prompt = compact_template.substitute(CONTEXT=history_text)
+
+        # Create input message for compaction
+        compact_message = Message(role="user", content=compact_prompt)
+
+        # Call generate to get the compacted context
+        # TODO: set max completion tokens
+        logger.debug("Compacting context...")
+        compacted_msg, usage = await generate(
+            chat_provider=llm.chat_provider,
+            system_prompt="You are a helpful assistant that compacts conversation context.",
+            tools=[],
+            history=[compact_message],
+        )
+        if usage:
+            logger.debug(
+                "Compaction used {input} input tokens and {output} output tokens",
+                input=usage.input,
+                output=usage.output,
+            )
+
+        content: list[ContentPart] = [
+            system("Previous context has been compacted. Here is the compaction output:")
+        ]
+        content.extend(
+            [TextPart(text=compacted_msg.content)]
+            if isinstance(compacted_msg.content, str)
+            else compacted_msg.content
+        )
+        compacted_messages: list[Message] = [Message(role="assistant", content=content)]
+        compacted_messages.extend(to_preserve)
+        return compacted_messages
+
+
+def __static_type_check(
+    simple: SimpleCompaction,
+):
+    _: Compaction = simple

kimi_cli/soul/kimisoul.py

@@ -1,4 +1,6 @@
 import asyncio
+from collections.abc import Sequence
+from functools import partial
 
 import kosong
 import tenacity
@@ -16,13 +18,24 @@ from tenacity import RetryCallState, retry_if_exception, stop_after_attempt, wai
 from kimi_cli.agent import Agent, AgentGlobals
 from kimi_cli.config import LoopControl
 from kimi_cli.soul import LLMNotSet, MaxStepsReached, Soul, StatusSnapshot
+from kimi_cli.soul.compaction import SimpleCompaction
 from kimi_cli.soul.context import Context
 from kimi_cli.soul.message import system, tool_result_to_messages
-from kimi_cli.soul.wire import StatusUpdate, StepBegin, StepInterrupted, Wire, current_wire
+from kimi_cli.soul.wire import (
+    CompactionBegin,
+    CompactionEnd,
+    StatusUpdate,
+    StepBegin,
+    StepInterrupted,
+    Wire,
+    current_wire,
+)
 from kimi_cli.tools.dmail import NAME as SendDMail_NAME
 from kimi_cli.tools.utils import ToolRejectedError
 from kimi_cli.utils.logging import logger
 
+RESERVED_TOKENS = 50_000
+
 
 class KimiSoul:
     """The soul of Kimi CLI."""
@@ -50,6 +63,10 @@ class KimiSoul:
         self._approval = agent_globals.approval
         self._context = context
         self._loop_control = 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
 
         for tool in agent.toolset.tools:
             if tool.name == SendDMail_NAME:
@@ -109,13 +126,21 @@ class KimiSoul:
             # to the main wire. See `_SubWire` for more details. Later we need to figure
             # out a better solution.
             try:
+                # compact the context if needed
+                if self._context.token_count >= self._reserved_tokens:
+                    logger.info("Context too long, compacting...")
+                    wire.send(CompactionBegin())
+                    await self.compact_context()
+                    wire.send(CompactionEnd())
+
+                logger.debug("Beginning step {step_no}", step_no=step_no)
                 await self._checkpoint()
                 self._denwa_renji.set_n_checkpoints(self._context.n_checkpoints)
                 finished = await self._step(wire)
             except BackToTheFuture as e:
                 await self._context.revert_to(e.checkpoint_id)
                 await self._checkpoint()
-                await self._context.append_message(e.message)
+                await self._context.append_message(e.messages)
                 continue
             except (ChatProviderError, asyncio.CancelledError):
                 wire.send(StepInterrupted())
@@ -137,28 +162,9 @@ class KimiSoul:
         assert self._agent_globals.llm is not None
         chat_provider = self._agent_globals.llm.chat_provider
 
-        def _is_retryable_error(exception: BaseException) -> bool:
-            if isinstance(exception, (APIConnectionError, APITimeoutError)):
-                return True
-            return isinstance(exception, APIStatusError) and exception.status_code in (
-                429,  # Too Many Requests
-                500,  # Internal Server Error
-                502,  # Bad Gateway
-                503,  # Service Unavailable
-            )
-
-        def _retry_log(retry_state: RetryCallState):
-            logger.info(
-                "Retrying step for the {n} time. Waiting {sleep} seconds.",
-                n=retry_state.attempt_number,
-                sleep=retry_state.next_action.sleep
-                if retry_state.next_action is not None
-                else "unknown",
-            )
-
         @tenacity.retry(
-            retry=retry_if_exception(_is_retryable_error),
-            before_sleep=_retry_log,
+            retry=retry_if_exception(self._is_retryable_error),
+            before_sleep=partial(self._retry_log, "step"),
             wait=wait_exponential_jitter(initial=0.3, max=5, jitter=0.5),
             stop=stop_after_attempt(self._loop_control.max_retries_per_step),
             reraise=True,
@@ -202,19 +208,21 @@ class KimiSoul:
             # raise to let the main loop take us back to the future
             raise BackToTheFuture(
                 dmail.checkpoint_id,
-                Message(
-                    role="user",
-                    content=[
-                        system(
-                            "You just got a D-Mail from your future self. "
-                            "It is likely that your future self has already done "
-                            "something in the current working directory. Please read "
-                            "the D-Mail and decide what to do next. You MUST NEVER "
-                            "mention to the user about this information. "
-                            f"D-Mail content:\n\n{dmail.message.strip()}"
-                        )
-                    ],
-                ),
+                [
+                    Message(
+                        role="user",
+                        content=[
+                            system(
+                                "You just got a D-Mail from your future self. "
+                                "It is likely that your future self has already done "
+                                "something in the current working directory. Please read "
+                                "the D-Mail and decide what to do next. You MUST NEVER "
+                                "mention to the user about this information. "
+                                f"D-Mail content:\n\n{dmail.message.strip()}"
+                            )
+                        ],
+                    )
+                ],
             )
 
         return not result.tool_calls
@@ -230,6 +238,54 @@ class KimiSoul:
             logger.debug("Appending tool result to context: {tool_result}", tool_result=tool_result)
             await self._context.append_message(tool_result_to_messages(tool_result))
 
+    async def compact_context(self) -> None:
+        """
+        Compact the context.
+
+        Raises:
+            LLMNotSet: When the LLM is not set.
+            ChatProviderError: When the chat provider returns an error.
+        """
+
+        @tenacity.retry(
+            retry=retry_if_exception(self._is_retryable_error),
+            before_sleep=partial(self._retry_log, "compaction"),
+            wait=wait_exponential_jitter(initial=0.3, max=5, jitter=0.5),
+            stop=stop_after_attempt(self._loop_control.max_retries_per_step),
+            reraise=True,
+        )
+        async def _compact_with_retry() -> Sequence[Message]:
+            if self._agent_globals.llm is None:
+                raise LLMNotSet()
+            return await self._compaction.compact(self._context.history, self._agent_globals.llm)
+
+        compacted_messages = await _compact_with_retry()
+        await self._context.revert_to(0)
+        await self._checkpoint()
+        await self._context.append_message(compacted_messages)
+
+    @staticmethod
+    def _is_retryable_error(exception: BaseException) -> bool:
+        if isinstance(exception, (APIConnectionError, APITimeoutError)):
+            return True
+        return isinstance(exception, APIStatusError) and exception.status_code in (
+            429,  # Too Many Requests
+            500,  # Internal Server Error
+            502,  # Bad Gateway
+            503,  # Service Unavailable
+        )
+
+    @staticmethod
+    def _retry_log(name: str, retry_state: RetryCallState):
+        logger.info(
+            "Retrying {name} for the {n} time. Waiting {sleep} seconds.",
+            name=name,
+            n=retry_state.attempt_number,
+            sleep=retry_state.next_action.sleep
+            if retry_state.next_action is not None
+            else "unknown",
+        )
+
 
 class BackToTheFuture(Exception):
     """
@@ -237,9 +293,9 @@ class BackToTheFuture(Exception):
     The main agent loop should catch this exception and handle it.
     """
 
-    def __init__(self, checkpoint_id: int, message: Message):
+    def __init__(self, checkpoint_id: int, messages: Sequence[Message]):
         self.checkpoint_id = checkpoint_id
-        self.message = message
+        self.messages = messages
 
 
 def __static_type_check(

kimi_cli/soul/wire.py

@@ -15,7 +15,26 @@ class StepBegin(NamedTuple):
     n: int
 
 
-class StepInterrupted(NamedTuple):
+class StepInterrupted:
+    pass
+
+
+class CompactionBegin:
+    """
+    Indicates that a compaction just began.
+    This event must be sent during a step, which means, between `StepBegin` and `StepInterrupted`.
+    And, there must be a `CompactionEnd` directly following this event.
+    """
+
+    pass
+
+
+class CompactionEnd:
+    """
+    Indicates that a compaction just ended.
+    This event must be sent directly after a `CompactionBegin` event.
+    """
+
     pass
 
 
@@ -23,7 +42,7 @@ class StatusUpdate(NamedTuple):
     status: StatusSnapshot
 
 
-type ControlFlowEvent = StepBegin | StepInterrupted | StatusUpdate
+type ControlFlowEvent = StepBegin | StepInterrupted | CompactionBegin | CompactionEnd | StatusUpdate
 type Event = ControlFlowEvent | ContentPart | ToolCall | ToolCallPart | ToolResult
 
 
@@ -34,9 +53,10 @@ class ApprovalResponse(Enum):
 
 
 class ApprovalRequest:
-    def __init__(self, tool_call_id: str, action: str, description: str):
+    def __init__(self, tool_call_id: str, sender: str, action: str, description: str):
         self.id = str(uuid.uuid4())
         self.tool_call_id = tool_call_id
+        self.sender = sender
         self.action = action
         self.description = description
         self._future = asyncio.Future[ApprovalResponse]()
@@ -44,7 +64,7 @@ class ApprovalRequest:
     def __repr__(self) -> str:
         return (
             f"ApprovalRequest(id={self.id}, tool_call_id={self.tool_call_id}, "
-            f"action={self.action}, description={self.description})"
+            f"sender={self.sender}, action={self.action}, description={self.description})"
         )
 
     async def wait(self) -> ApprovalResponse:
@@ -63,6 +83,11 @@ class ApprovalRequest:
         """
         self._future.set_result(response)
 
+    @property
+    def resolved(self) -> bool:
+        """Whether the request is resolved."""
+        return self._future.done()
+
 
 type WireMessage = Event | ApprovalRequest
 

kimi_cli/tools/bash/__init__.py

@@ -38,7 +38,9 @@ class Bash(CallableTool2[Params]):
         builder = ToolResultBuilder()
 
         if not await self._approval.request(
-            f"run command {params.command}", f"Run command `{params.command}`"
+            self.name,
+            "run shell command",
+            f"Run command `{params.command}`",
         ):
             return ToolRejectedError()
 

kimi_cli/tools/file/__init__.py

@@ -1,9 +1,17 @@
+from enum import Enum
+
+
 class FileOpsWindow:
     """Maintains a window of file operations."""
 
     pass
 
 
+class FileActions(str, Enum):
+    READ = "read file"
+    EDIT = "edit file"
+
+
 from .glob import Glob  # noqa: E402
 from .grep import Grep  # noqa: E402
 from .patch import PatchFile  # noqa: E402

kimi_cli/tools/file/patch.py

@@ -7,6 +7,9 @@ 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.tools.file import FileActions
+from kimi_cli.tools.utils import ToolRejectedError
 
 
 class Params(BaseModel):
@@ -19,9 +22,10 @@ class PatchFile(CallableTool2[Params]):
     description: str = (Path(__file__).parent / "patch.md").read_text()
     params: type[Params] = Params
 
-    def __init__(self, builtin_args: BuiltinSystemPromptArgs, **kwargs):
+    def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval, **kwargs):
         super().__init__(**kwargs)
         self._work_dir = builtin_args.KIMI_WORK_DIR
+        self._approval = approval
 
     def _validate_path(self, path: Path) -> ToolError | None:
         """Validate that the path is safe to patch."""
@@ -70,6 +74,14 @@ class PatchFile(CallableTool2[Params]):
                     brief="Invalid path",
                 )
 
+            # Request approval
+            if not await self._approval.request(
+                self.name,
+                FileActions.EDIT,
+                f"Patch file `{params.path}`",
+            ):
+                return ToolRejectedError()
+
             # Read the file content
             async with aiofiles.open(p, encoding="utf-8", errors="replace") as f:
                 original_content = await f.read()

kimi_cli/tools/file/replace.py

@@ -6,6 +6,9 @@ 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.tools.file import FileActions
+from kimi_cli.tools.utils import ToolRejectedError
 
 
 class Edit(BaseModel):
@@ -29,9 +32,10 @@ class StrReplaceFile(CallableTool2[Params]):
     description: str = (Path(__file__).parent / "replace.md").read_text()
     params: type[Params] = Params
 
-    def __init__(self, builtin_args: BuiltinSystemPromptArgs, **kwargs):
+    def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval, **kwargs):
         super().__init__(**kwargs)
         self._work_dir = builtin_args.KIMI_WORK_DIR
+        self._approval = approval
 
     def _validate_path(self, path: Path) -> ToolError | None:
         """Validate that the path is safe to edit."""
@@ -87,6 +91,14 @@ class StrReplaceFile(CallableTool2[Params]):
                     brief="Invalid path",
                 )
 
+            # Request approval
+            if not await self._approval.request(
+                self.name,
+                FileActions.EDIT,
+                f"Edit file `{params.path}`",
+            ):
+                return ToolRejectedError()
+
             # Read the file content
             async with aiofiles.open(p, encoding="utf-8", errors="replace") as f:
                 content = await f.read()

kimi_cli/tools/file/write.py

@@ -6,6 +6,9 @@ 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.tools.file import FileActions
+from kimi_cli.tools.utils import ToolRejectedError
 
 
 class Params(BaseModel):
@@ -26,9 +29,10 @@ class WriteFile(CallableTool2[Params]):
     description: str = (Path(__file__).parent / "write.md").read_text()
     params: type[Params] = Params
 
-    def __init__(self, builtin_args: BuiltinSystemPromptArgs, **kwargs):
+    def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval, **kwargs):
         super().__init__(**kwargs)
         self._work_dir = builtin_args.KIMI_WORK_DIR
+        self._approval = approval
 
     def _validate_path(self, path: Path) -> ToolError | None:
         """Validate that the path is safe to write."""
@@ -85,6 +89,14 @@ class WriteFile(CallableTool2[Params]):
                     brief="Invalid write mode",
                 )
 
+            # Request approval
+            if not await self._approval.request(
+                self.name,
+                FileActions.EDIT,
+                f"Write file `{params.path}`",
+            ):
+                return ToolRejectedError()
+
             # Determine file mode for aiofiles
             file_mode = "w" if params.mode == "overwrite" else "a"
 

kimi_cli/ui/__init__.py

@@ -28,6 +28,7 @@ async def run_soul(
     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.

kimi_cli/ui/print/__init__.py

@@ -155,6 +155,7 @@ class PrintApp:
             logger.debug("Visualization loop shutting down")
 
     async def _visualize_stream_json(self, wire: Wire, start_position: int):
+        # TODO: be aware of context compaction
         try:
             async with aiofiles.open(self.soul._context._file_backend, encoding="utf-8") as f:
                 await f.seek(start_position)