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

kimi_cli/soul/kimisoul.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 import kosong
 import tenacity
 from kosong import StepResult
-from kosong.base.message import Message
+from kosong.base.message import ContentPart, ImageURLPart, Message
 from kosong.chat_provider import (
     APIConnectionError,
     APIStatusError,
@@ -16,7 +16,14 @@ 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.soul import LLMNotSet, MaxStepsReached, Soul, StatusSnapshot, wire_send
+from kimi_cli.soul import (
+    LLMNotSet,
+    LLMNotSupported,
+    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
@@ -53,7 +60,6 @@ class KimiSoul(Soul):
             agent (Agent): The agent to run.
             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._runtime = runtime
@@ -85,6 +91,10 @@ class KimiSoul(Soul):
     def status(self) -> StatusSnapshot:
         return StatusSnapshot(context_usage=self._context_usage)
 
+    @property
+    def context(self) -> Context:
+        return self._context
+
     @property
     def _context_usage(self) -> float:
         if self._runtime.llm is not None:
@@ -94,10 +104,17 @@ class KimiSoul(Soul):
     async def _checkpoint(self):
         await self._context.checkpoint(self._checkpoint_with_user_message)
 
-    async def run(self, user_input: str):
+    async def run(self, user_input: str | list[ContentPart]):
         if self._runtime.llm is None:
             raise LLMNotSet()
 
+        if (
+            isinstance(user_input, list)
+            and any(isinstance(part, ImageURLPart) for part in user_input)
+            and not self._runtime.llm.supports_image_in
+        ):
+            raise LLMNotSupported(self._runtime.llm, ["image_in"])
+
         await self._checkpoint()  # this creates the checkpoint 0 on first run
         await self._context.append_message(Message(role="user", content=user_input))
         logger.debug("Appended user message to context")

kimi_cli/soul/message.py

@@ -14,7 +14,7 @@ def tool_result_to_messages(tool_result: ToolResult) -> list[Message]:
         message = tool_result.result.message
         if isinstance(tool_result.result, ToolRuntimeError):
             message += "\nThis is an unexpected error and the tool is probably not working."
-        content: list[ContentPart] = [system(message)]
+        content: list[ContentPart] = [system(f"ERROR: {message}")]
         if tool_result.result.output:
             content.append(TextPart(text=tool_result.result.output))
         return [

kimi_cli/soul/runtime.py

@@ -1,3 +1,4 @@
+import asyncio
 import subprocess
 import sys
 from datetime import datetime
@@ -59,7 +60,7 @@ def _list_work_dir(work_dir: Path) -> str:
 
 
 class Runtime(NamedTuple):
-    """Agent globals."""
+    """Agent runtime."""
 
     config: Config
     llm: LLM | None
@@ -75,9 +76,10 @@ class Runtime(NamedTuple):
         session: Session,
         yolo: bool,
     ) -> "Runtime":
-        # FIXME: do these asynchronously
-        ls_output = _list_work_dir(session.work_dir)
-        agents_md = load_agents_md(session.work_dir) or ""
+        ls_output, agents_md = await asyncio.gather(
+            asyncio.to_thread(_list_work_dir, session.work_dir),
+            asyncio.to_thread(load_agents_md, session.work_dir),
+        )
 
         return Runtime(
             config=config,
@@ -87,7 +89,7 @@ class Runtime(NamedTuple):
                 KIMI_NOW=datetime.now().astimezone().isoformat(),
                 KIMI_WORK_DIR=session.work_dir,
                 KIMI_WORK_DIR_LS=ls_output,
-                KIMI_AGENTS_MD=agents_md,
+                KIMI_AGENTS_MD=agents_md or "",
             ),
             denwa_renji=DenwaRenji(),
             approval=Approval(yolo=yolo),

kimi_cli/tools/task/__init__.py

@@ -68,7 +68,8 @@ class Task(CallableTool2[Params]):
         self._subagents: dict[str, Agent] = {}
 
         try:
-            self._load_task = asyncio.create_task(self._load_subagents(agent_spec.subagents))
+            loop = asyncio.get_running_loop()
+            self._load_task = loop.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

kimi_cli/tools/web/search.py

@@ -44,7 +44,7 @@ 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
+            self._custom_headers = config.services.moonshot_search.custom_headers or {}
         else:
             self._base_url = ""
             self._api_key = ""

kimi_cli/ui/acp/__init__.py

@@ -172,33 +172,29 @@ class ACPAgent:
             self.run_state.cancel_event.set()
 
     async def _stream_events(self, wire: WireUISide):
-        try:
-            # expect a StepBegin
-            assert isinstance(await wire.receive(), StepBegin)
-
-            while True:
-                msg = await wire.receive()
-
-                if isinstance(msg, TextPart):
-                    await self._send_text(msg.text)
-                elif isinstance(msg, ContentPart):
-                    logger.warning("Unsupported content part: {part}", part=msg)
-                    await self._send_text(f"[{msg.__class__.__name__}]")
-                elif isinstance(msg, ToolCall):
-                    await self._send_tool_call(msg)
-                elif isinstance(msg, ToolCallPart):
-                    await self._send_tool_call_part(msg)
-                elif isinstance(msg, ToolResult):
-                    await self._send_tool_result(msg)
-                elif isinstance(msg, ApprovalRequest):
-                    await self._handle_approval_request(msg)
-                elif isinstance(msg, StatusUpdate):
-                    # TODO: stream status if needed
-                    pass
-                elif isinstance(msg, StepInterrupted):
-                    break
-        except asyncio.QueueShutDown:
-            logger.debug("Event stream loop shutting down")
+        assert isinstance(await wire.receive(), StepBegin)
+
+        while True:
+            msg = await wire.receive()
+
+            if isinstance(msg, TextPart):
+                await self._send_text(msg.text)
+            elif isinstance(msg, ContentPart):
+                logger.warning("Unsupported content part: {part}", part=msg)
+                await self._send_text(f"[{msg.__class__.__name__}]")
+            elif isinstance(msg, ToolCall):
+                await self._send_tool_call(msg)
+            elif isinstance(msg, ToolCallPart):
+                await self._send_tool_call_part(msg)
+            elif isinstance(msg, ToolResult):
+                await self._send_tool_result(msg)
+            elif isinstance(msg, ApprovalRequest):
+                await self._handle_approval_request(msg)
+            elif isinstance(msg, StatusUpdate):
+                # TODO: stream status if needed
+                pass
+            elif isinstance(msg, StepInterrupted):
+                break
 
     async def _send_text(self, text: str):
         """Send text chunk to client."""
@@ -321,7 +317,7 @@ class ACPAgent:
         # Create permission request with options
         permission_request = acp.RequestPermissionRequest(
             sessionId=self.session_id,
-            toolCall=acp.schema.ToolCallUpdate(
+            toolCall=acp.schema.ToolCall(
                 toolCallId=state.acp_tool_call_id,
                 content=[
                     acp.schema.ContentToolCallContent(

kimi_cli/ui/print/__init__.py

@@ -1,24 +1,22 @@
 import asyncio
 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 rich import print
 
+from kimi_cli.cli import InputFormat, OutputFormat
 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.utils.signals import install_sigint_handler
 from kimi_cli.wire import WireUISide
 from kimi_cli.wire.message import StepInterrupted
 
-InputFormat = Literal["text", "stream-json"]
-OutputFormat = Literal["text", "stream-json"]
-
 
 class PrintApp:
     """
@@ -51,7 +49,7 @@ class PrintApp:
             cancel_event.set()
 
         loop = asyncio.get_running_loop()
-        loop.add_signal_handler(signal.SIGINT, _handler)
+        remove_sigint = install_sigint_handler(loop, _handler)
 
         if command is None and not sys.stdin.isatty() and self.input_format == "text":
             command = sys.stdin.read().strip()
@@ -98,7 +96,7 @@ class PrintApp:
             print(f"Unknown error: {e}")
             raise
         finally:
-            loop.remove_signal_handler(signal.SIGINT)
+            remove_sigint()
         return False
 
     def _read_next_command(self) -> str | None:
@@ -127,35 +125,29 @@ class PrintApp:
                 logger.warning("Ignoring invalid user message: {json_line}", json_line=json_line)
 
     async def _visualize_text(self, wire: WireUISide):
-        try:
-            while True:
-                msg = await wire.receive()
-                print(msg)
-                if isinstance(msg, StepInterrupted):
-                    break
-        except asyncio.QueueShutDown:
-            logger.debug("Visualization loop shutting down")
+        while True:
+            msg = await wire.receive()
+            print(msg)
+            if isinstance(msg, StepInterrupted):
+                break
 
     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 (msg := wire.receive_nowait()) is not None:
-                        if isinstance(msg, StepInterrupted):
-                            should_end = True
-
-                    line = await f.readline()
-                    if not line:
-                        if should_end:
-                            break
-                        await asyncio.sleep(0.1)
-                        continue
-                    print(line, end="")
-        except asyncio.QueueShutDown:
-            logger.debug("Visualization loop shutting down")
+        async with aiofiles.open(self.context_file, encoding="utf-8") as f:
+            await f.seek(start_position)
+            while True:
+                should_end = False
+                while (msg := wire.receive_nowait()) is not None:
+                    if isinstance(msg, StepInterrupted):
+                        should_end = True
+
+                line = await f.readline()
+                if not line:
+                    if should_end:
+                        break
+                    await asyncio.sleep(0.1)
+                    continue
+                print(line, end="")

kimi_cli/ui/shell/__init__.py

@@ -1,28 +1,32 @@
 import asyncio
-import signal
 from collections.abc import Awaitable, Coroutine
+from dataclasses import dataclass
+from enum import Enum
 from typing import Any
 
+from kosong.base.message import ContentPart
 from kosong.chat_provider import APIStatusError, ChatProviderError
 from rich.console import Group, RenderableType
 from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
 
-from kimi_cli.soul import LLMNotSet, MaxStepsReached, RunCancelled, Soul, run_soul
+from kimi_cli.soul import LLMNotSet, LLMNotSupported, MaxStepsReached, RunCancelled, Soul, run_soul
 from kimi_cli.soul.kimisoul import KimiSoul
 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
+from kimi_cli.ui.shell.prompt import CustomPromptSession, PromptMode, ensure_new_line, toast
+from kimi_cli.ui.shell.replay import replay_recent_history
 from kimi_cli.ui.shell.update import LATEST_VERSION_FILE, UpdateResult, do_update, semver_tuple
 from kimi_cli.ui.shell.visualize import visualize
 from kimi_cli.utils.logging import logger
+from kimi_cli.utils.signals import install_sigint_handler
 
 
 class ShellApp:
-    def __init__(self, soul: Soul, welcome_info: dict[str, str] | None = None):
+    def __init__(self, soul: Soul, welcome_info: list["WelcomeInfoItem"] | None = None):
         self.soul = soul
-        self.welcome_info = welcome_info or {}
+        self._welcome_info = list(welcome_info or [])
         self._background_tasks: set[asyncio.Task[Any]] = set()
 
     async def run(self, command: str | None = None) -> bool:
@@ -33,11 +37,15 @@ class ShellApp:
 
         self._start_background_task(self._auto_update())
 
-        _print_welcome_info(self.soul.name or "Kimi CLI", self.soul.model, self.welcome_info)
+        _print_welcome_info(self.soul.name or "Kimi CLI", self._welcome_info)
+
+        if isinstance(self.soul, KimiSoul):
+            await replay_recent_history(self.soul.context.history)
 
         with CustomPromptSession(lambda: self.soul.status) as prompt_session:
             while True:
                 try:
+                    ensure_new_line()
                     user_input = await prompt_session.prompt()
                 except KeyboardInterrupt:
                     logger.debug("Exiting by KeyboardInterrupt")
@@ -62,14 +70,13 @@ class ShellApp:
                     await self._run_shell_command(user_input.command)
                     continue
 
-                command = user_input.command
-                if command.startswith("/"):
-                    logger.debug("Running meta command: {command}", command=command)
-                    await self._run_meta_command(command[1:])
+                if user_input.command.startswith("/"):
+                    logger.debug("Running meta command: {command}", command=user_input.command)
+                    await self._run_meta_command(user_input.command[1:])
                     continue
 
-                logger.info("Running agent command: {command}", command=command)
-                await self._run_soul_command(command)
+                logger.info("Running agent command: {command}", command=user_input.content)
+                await self._run_soul_command(user_input.content)
 
         return True
 
@@ -79,24 +86,26 @@ class ShellApp:
             return
 
         logger.info("Running shell command: {cmd}", cmd=command)
+
+        proc: asyncio.subprocess.Process | None = None
+
+        def _handler():
+            logger.debug("SIGINT received.")
+            if proc:
+                proc.terminate()
+
         loop = asyncio.get_running_loop()
+        remove_sigint = install_sigint_handler(loop, _handler)
         try:
             # TODO: For the sake of simplicity, we now use `create_subprocess_shell`.
             # Later we should consider making this behave like a real shell.
             proc = await asyncio.create_subprocess_shell(command)
-
-            def _handler():
-                logger.debug("SIGINT received.")
-                proc.terminate()
-
-            loop.add_signal_handler(signal.SIGINT, _handler)
-
             await proc.wait()
         except Exception as e:
             logger.exception("Failed to run shell command:")
             console.print(f"[red]Failed to run shell command: {e}[/red]")
         finally:
-            loop.remove_signal_handler(signal.SIGINT)
+            remove_sigint()
 
     async def _run_meta_command(self, command_str: str):
         from kimi_cli.cli import Reload
@@ -137,7 +146,7 @@ class ShellApp:
             console.print(f"[red]Unknown error: {e}[/red]")
             raise  # re-raise unknown error
 
-    async def _run_soul_command(self, command: str) -> bool:
+    async def _run_soul_command(self, user_input: str | list[ContentPart]) -> bool:
         """
         Run the soul and handle any known exceptions.
 
@@ -151,13 +160,13 @@ class ShellApp:
             cancel_event.set()
 
         loop = asyncio.get_running_loop()
-        loop.add_signal_handler(signal.SIGINT, _handler)
+        remove_sigint = install_sigint_handler(loop, _handler)
 
         try:
             # Use lambda to pass cancel_event via closure
             await run_soul(
                 self.soul,
-                command,
+                user_input,
                 lambda wire: visualize(
                     wire, initial_status=self.soul.status, cancel_event=cancel_event
                 ),
@@ -167,6 +176,13 @@ class ShellApp:
         except LLMNotSet:
             logger.error("LLM not set")
             console.print("[red]LLM not set, send /setup to configure[/red]")
+        except LLMNotSupported as e:
+            logger.error(
+                "LLM model '{model_name}' does not support required capabilities: {capabilities}",
+                model_name=e.llm.model_name,
+                capabilities=", ".join(e.capabilities),
+            )
+            console.print(f"[red]{e}[/red]")
         except ChatProviderError as e:
             logger.exception("LLM provider error:")
             if isinstance(e, APIStatusError) and e.status_code == 401:
@@ -188,7 +204,7 @@ class ShellApp:
             console.print(f"[red]Unknown error: {e}[/red]")
             raise  # re-raise unknown error
         finally:
-            loop.remove_signal_handler(signal.SIGINT)
+            remove_sigint()
         return False
 
     async def _auto_update(self) -> None:
@@ -227,7 +243,19 @@ _LOGO = f"""\
 """
 
 
-def _print_welcome_info(name: str, model: str, info_items: dict[str, str]) -> None:
+@dataclass(slots=True)
+class WelcomeInfoItem:
+    class Level(Enum):
+        INFO = "grey50"
+        WARN = "yellow"
+        ERROR = "red"
+
+    name: str
+    value: str
+    level: Level = Level.INFO
+
+
+def _print_welcome_info(name: str, info_items: list[WelcomeInfoItem]) -> None:
     head = Text.from_markup(f"[bold]Welcome to {name}![/bold]")
     help_text = Text.from_markup("[grey50]Send /help for help information.[/grey50]")
 
@@ -241,17 +269,8 @@ def _print_welcome_info(name: str, model: str, info_items: dict[str, str]) -> No
     rows: list[RenderableType] = [table]
 
     rows.append(Text(""))  # Empty line
-    rows.extend(
-        Text.from_markup(f"[grey50]{key}: {value}[/grey50]") for key, value in info_items.items()
-    )
-    if model:
-        rows.append(Text.from_markup(f"[grey50]Model: {model}[/grey50]"))
-    else:
-        rows.append(
-            Text.from_markup(
-                "[grey50]Model:[/grey50] [yellow]not set, send /setup to configure[/yellow]"
-            )
-        )
+    for item in info_items:
+        rows.append(Text(f"{item.name}: {item.value}", style=item.level.value))
 
     if LATEST_VERSION_FILE.exists():
         from kimi_cli.constant import VERSION as current_version

kimi_cli/ui/shell/keyboard.py

@@ -1,6 +1,5 @@
 import asyncio
 import sys
-import termios
 import threading
 import time
 from collections.abc import AsyncGenerator, Callable
@@ -47,6 +46,21 @@ def _listen_for_keyboard_thread(
     cancel: threading.Event,
     emit: Callable[[KeyEvent], None],
 ) -> None:
+    if sys.platform == "win32":
+        _listen_for_keyboard_windows(cancel, emit)
+    else:
+        _listen_for_keyboard_unix(cancel, emit)
+
+
+def _listen_for_keyboard_unix(
+    cancel: threading.Event,
+    emit: Callable[[KeyEvent], None],
+) -> None:
+    if sys.platform == "win32":
+        raise RuntimeError("Unix keyboard listener requires a non-Windows platform")
+
+    import termios
+
     # make stdin raw and non-blocking
     fd = sys.stdin.fileno()
     oldterm = termios.tcgetattr(fd)
@@ -59,9 +73,9 @@ def _listen_for_keyboard_thread(
     try:
         while not cancel.is_set():
             try:
-                c = sys.stdin.read(1)
+                c = sys.stdin.buffer.read(1)
             except (OSError, ValueError):
-                c = ""
+                c = b""
 
             if not c:
                 if cancel.is_set():
@@ -69,15 +83,15 @@ def _listen_for_keyboard_thread(
                 time.sleep(0.01)
                 continue
 
-            if c == "\x1b":
+            if c == b"\x1b":
                 sequence = c
                 for _ in range(2):
                     if cancel.is_set():
                         break
                     try:
-                        fragment = sys.stdin.read(1)
+                        fragment = sys.stdin.buffer.read(1)
                     except (OSError, ValueError):
-                        fragment = ""
+                        fragment = b""
                     if not fragment:
                         break
                     sequence += fragment
@@ -87,22 +101,76 @@ def _listen_for_keyboard_thread(
                 event = _ARROW_KEY_MAP.get(sequence)
                 if event is not None:
                     emit(event)
-                elif sequence == "\x1b":
+                elif sequence == b"\x1b":
                     emit(KeyEvent.ESCAPE)
-            elif c in ("\r", "\n"):
+            elif c in (b"\r", b"\n"):
                 emit(KeyEvent.ENTER)
-            elif c == "\t":
+            elif c == b"\t":
                 emit(KeyEvent.TAB)
     finally:
         # restore the terminal settings
         termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)
 
 
-_ARROW_KEY_MAP: dict[str, KeyEvent] = {
-    "\x1b[A": KeyEvent.UP,
-    "\x1b[B": KeyEvent.DOWN,
-    "\x1b[C": KeyEvent.RIGHT,
-    "\x1b[D": KeyEvent.LEFT,
+def _listen_for_keyboard_windows(
+    cancel: threading.Event,
+    emit: Callable[[KeyEvent], None],
+) -> None:
+    if sys.platform != "win32":
+        raise RuntimeError("Windows keyboard listener requires a Windows platform")
+
+    import msvcrt
+
+    while not cancel.is_set():
+        if msvcrt.kbhit():
+            c = msvcrt.getch()
+
+            # Handle special keys (arrow keys, etc.)
+            if c in (b"\x00", b"\xe0"):
+                # Extended key, read the next byte
+                extended = msvcrt.getch()
+                event = _WINDOWS_KEY_MAP.get(extended)
+                if event is not None:
+                    emit(event)
+            elif c == b"\x1b":
+                sequence = c
+                for _ in range(2):
+                    if cancel.is_set():
+                        break
+                    fragment = msvcrt.getch() if msvcrt.kbhit() else b""
+                    if not fragment:
+                        break
+                    sequence += fragment
+                    if sequence in _ARROW_KEY_MAP:
+                        break
+
+                event = _ARROW_KEY_MAP.get(sequence)
+                if event is not None:
+                    emit(event)
+                elif sequence == b"\x1b":
+                    emit(KeyEvent.ESCAPE)
+            elif c in (b"\r", b"\n"):
+                emit(KeyEvent.ENTER)
+            elif c == b"\t":
+                emit(KeyEvent.TAB)
+        else:
+            if cancel.is_set():
+                break
+            time.sleep(0.01)
+
+
+_ARROW_KEY_MAP: dict[bytes, KeyEvent] = {
+    b"\x1b[A": KeyEvent.UP,
+    b"\x1b[B": KeyEvent.DOWN,
+    b"\x1b[C": KeyEvent.RIGHT,
+    b"\x1b[D": KeyEvent.LEFT,
+}
+
+_WINDOWS_KEY_MAP: dict[bytes, KeyEvent] = {
+    b"H": KeyEvent.UP,  # Up arrow
+    b"P": KeyEvent.DOWN,  # Down arrow
+    b"M": KeyEvent.RIGHT,  # Right arrow
+    b"K": KeyEvent.LEFT,  # Left arrow
 }