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

kimi_cli/CHANGELOG.md

@@ -9,6 +9,19 @@ Internal builds may append content to the Unreleased section.
 Only write entries that are worth mentioning to users.
 -->
 
+## [0.43] - 2025-10-30
+
+### Added
+
+- Basic Windows support (experimental)
+- Display warnings when base URL or API key is overridden in environment variables
+- Support image input if the LLM model supports it
+- Replay recent context history when continuing a session
+
+### Fixed
+
+- Ensure new line after executing shell commands
+
 ## [0.42] - 2025-10-28
 
 ### Added

kimi_cli/__init__.py

@@ -17,7 +17,7 @@ from kimi_cli.soul.kimisoul import KimiSoul
 from kimi_cli.soul.runtime import Runtime
 from kimi_cli.ui.acp import ACPServer
 from kimi_cli.ui.print import InputFormat, OutputFormat, PrintApp
-from kimi_cli.ui.shell import ShellApp
+from kimi_cli.ui.shell import ShellApp, WelcomeInfoItem
 from kimi_cli.utils.logging import StreamToLogger, logger
 
 
@@ -72,7 +72,7 @@ class KimiCLI:
         # try overwrite with environment variables
         assert provider is not None
         assert model is not None
-        augment_provider_with_env_vars(provider, model)
+        env_overrides = augment_provider_with_env_vars(provider, model)
 
         if not provider.base_url or not model.model:
             llm = None
@@ -81,6 +81,43 @@ class KimiCLI:
             logger.info("Using LLM model: {model}", model=model)
             llm = create_llm(provider, model, stream=stream, session_id=session.id)
 
+        welcome_info = [
+            WelcomeInfoItem(name="Directory", value=str(session.work_dir)),
+            WelcomeInfoItem(name="Session", value=session.id),
+        ]
+        if base_url := env_overrides.get("KIMI_BASE_URL"):
+            welcome_info.append(
+                WelcomeInfoItem(
+                    name="API URL",
+                    value=f"{base_url} (from KIMI_BASE_URL)",
+                    level=WelcomeInfoItem.Level.WARN,
+                )
+            )
+        if not llm:
+            welcome_info.append(
+                WelcomeInfoItem(
+                    name="Model",
+                    value="not set, send /setup to configure",
+                    level=WelcomeInfoItem.Level.WARN,
+                )
+            )
+        elif "KIMI_MODEL_NAME" in env_overrides:
+            welcome_info.append(
+                WelcomeInfoItem(
+                    name="Model",
+                    value=f"{model.model} (from KIMI_MODEL_NAME)",
+                    level=WelcomeInfoItem.Level.WARN,
+                )
+            )
+        else:
+            welcome_info.append(
+                WelcomeInfoItem(
+                    name="Model",
+                    value=model.model,
+                    level=WelcomeInfoItem.Level.INFO,
+                )
+            )
+
         runtime = await Runtime.create(config, llm, session, yolo)
 
         if agent_file is None:
@@ -95,11 +132,17 @@ class KimiCLI:
             runtime,
             context=context,
         )
-        return KimiCLI(soul, session)
+        return KimiCLI(soul, session, welcome_info)
 
-    def __init__(self, soul: KimiSoul, session: Session) -> None:
+    def __init__(
+        self,
+        soul: KimiSoul,
+        session: Session,
+        welcome_info: list[WelcomeInfoItem],
+    ) -> None:
         self._soul = soul
         self._session = session
+        self._welcome_info = welcome_info
 
     @property
     def soul(self) -> KimiSoul:
@@ -125,13 +168,7 @@ class KimiCLI:
 
     async def run_shell_mode(self, command: str | None = None) -> bool:
         with self._app_env():
-            app = ShellApp(
-                self._soul,
-                welcome_info={
-                    "Directory": str(self._session.work_dir),
-                    "Session": self._session.id,
-                },
-            )
+            app = ShellApp(self._soul, welcome_info=self._welcome_info)
             return await app.run(command)
 
     async def run_print_mode(

kimi_cli/config.py

@@ -18,7 +18,7 @@ class LLMProvider(BaseModel):
     """API base URL"""
     api_key: SecretStr
     """API key"""
-    custom_headers: dict[str, str] = Field(default_factory=dict)
+    custom_headers: dict[str, str] | None = None
     """Custom headers to include in API requests"""
 
     @field_serializer("api_key", when_used="json")
@@ -26,6 +26,9 @@ class LLMProvider(BaseModel):
         return v.get_secret_value()
 
 
+LLMModelCapability = Literal["image_in"]
+
+
 class LLMModel(BaseModel):
     """LLM model configuration."""
 
@@ -35,6 +38,8 @@ class LLMModel(BaseModel):
     """Model name"""
     max_context_size: int
     """Maximum context size (unit: tokens)"""
+    capabilities: set[LLMModelCapability] | None = None
+    """Model capabilities"""
 
 
 class LoopControl(BaseModel):
@@ -53,7 +58,7 @@ class MoonshotSearchConfig(BaseModel):
     """Base URL for Moonshot Search service."""
     api_key: SecretStr
     """API key for Moonshot Search service."""
-    custom_headers: dict[str, str] = Field(default_factory=dict)
+    custom_headers: dict[str, str] | None = None
     """Custom headers to include in API requests."""
 
     @field_serializer("api_key", when_used="json")

kimi_cli/llm.py

@@ -7,26 +7,47 @@ from kosong.chat_provider.kimi import Kimi
 from kosong.chat_provider.openai_legacy import OpenAILegacy
 from pydantic import SecretStr
 
-from kimi_cli.config import LLMModel, LLMProvider
+from kimi_cli.config import LLMModel, LLMModelCapability, LLMProvider
 from kimi_cli.constant import USER_AGENT
 
 
 class LLM(NamedTuple):
     chat_provider: ChatProvider
     max_context_size: int
+    capabilities: set[LLMModelCapability]
+    # TODO: these additional fields should be moved to ChatProvider
 
+    @property
+    def model_name(self) -> str:
+        return self.chat_provider.model_name
+
+    @property
+    def supports_image_in(self) -> bool:
+        return "image_in" in self.capabilities
+
+
+def augment_provider_with_env_vars(provider: LLMProvider, model: LLMModel) -> dict[str, str]:
+    """Override provider/model settings from environment variables.
+
+    Returns:
+        Mapping of environment variables that were applied.
+    """
+    applied: dict[str, str] = {}
 
-def augment_provider_with_env_vars(provider: LLMProvider, model: LLMModel):
     match provider.type:
         case "kimi":
             if base_url := os.getenv("KIMI_BASE_URL"):
                 provider.base_url = base_url
+                applied["KIMI_BASE_URL"] = base_url
             if api_key := os.getenv("KIMI_API_KEY"):
                 provider.api_key = SecretStr(api_key)
+                applied["KIMI_API_KEY"] = "******"
             if model_name := os.getenv("KIMI_MODEL_NAME"):
                 model.model = model_name
+                applied["KIMI_MODEL_NAME"] = model.model
             if max_context_size := os.getenv("KIMI_MODEL_MAX_CONTEXT_SIZE"):
                 model.max_context_size = int(max_context_size)
+                applied["KIMI_MODEL_MAX_CONTEXT_SIZE"] = str(model.max_context_size)
         case "openai_legacy":
             if base_url := os.getenv("OPENAI_BASE_URL"):
                 provider.base_url = base_url
@@ -35,6 +56,8 @@ def augment_provider_with_env_vars(provider: LLMProvider, model: LLMModel):
         case _:
             pass
 
+    return applied
+
 
 def create_llm(
     provider: LLMProvider,
@@ -52,7 +75,7 @@ def create_llm(
                 stream=stream,
                 default_headers={
                     "User-Agent": USER_AGENT,
-                    **provider.custom_headers,
+                    **(provider.custom_headers or {}),
                 },
             )
             if session_id:
@@ -75,4 +98,8 @@ def create_llm(
                 ),
             )
 
-    return LLM(chat_provider=chat_provider, max_context_size=model.max_context_size)
+    return LLM(
+        chat_provider=chat_provider,
+        max_context_size=model.max_context_size,
+        capabilities=model.capabilities or set(),
+    )

kimi_cli/soul/__init__.py

@@ -4,6 +4,9 @@ from collections.abc import Callable, Coroutine
 from contextvars import ContextVar
 from typing import Any, NamedTuple, Protocol, runtime_checkable
 
+from kosong.base.message import ContentPart
+
+from kimi_cli.llm import LLM
 from kimi_cli.utils.logging import logger
 from kimi_cli.wire import Wire, WireUISide
 from kimi_cli.wire.message import WireMessage
@@ -15,6 +18,19 @@ class LLMNotSet(Exception):
     pass
 
 
+class LLMNotSupported(Exception):
+    """Raised when the LLM does not have required capabilities."""
+
+    def __init__(self, llm: LLM, capabilities: list[str]):
+        self.llm = llm
+        self.capabilities = capabilities
+        capabilities_str = "capability" if len(capabilities) == 1 else "capabilities"
+        super().__init__(
+            f"The LLM model '{llm.model_name}' does not support required {capabilities_str}: "
+            f"{', '.join(capabilities)}."
+        )
+
+
 class MaxStepsReached(Exception):
     """Raised when the maximum number of steps is reached."""
 
@@ -47,15 +63,16 @@ class Soul(Protocol):
         """The current status of the soul. The returned value is immutable."""
         ...
 
-    async def run(self, user_input: str):
+    async def run(self, user_input: str | list[ContentPart]):
         """
         Run the agent with the given user input until the max steps or no more tool calls.
 
         Args:
-            user_input (str): The user input to the agent.
+            user_input (str | list[ContentPart]): The user input to the agent.
 
         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.
             asyncio.CancelledError: When the run is cancelled by user.
@@ -73,7 +90,7 @@ class RunCancelled(Exception):
 
 async def run_soul(
     soul: "Soul",
-    user_input: str,
+    user_input: str | list[ContentPart],
     ui_loop_fn: UILoopFn,
     cancel_event: asyncio.Event,
 ) -> None:
@@ -85,6 +102,7 @@ async def run_soul(
 
     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.
@@ -125,7 +143,7 @@ async def run_soul(
         try:
             await asyncio.wait_for(ui_task, timeout=0.5)
         except asyncio.QueueShutDown:
-            # expected
+            logger.debug("UI loop shut down")
             pass
         except TimeoutError:
             logger.warning("UI loop timed out")

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

@@ -59,7 +59,7 @@ def _list_work_dir(work_dir: Path) -> str:
 
 
 class Runtime(NamedTuple):
-    """Agent globals."""
+    """Agent runtime."""
 
     config: Config
     llm: LLM | None

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,6 +1,5 @@
 import asyncio
 import json
-import signal
 import sys
 from functools import partial
 from pathlib import Path
@@ -9,10 +8,12 @@ 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.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
 
@@ -51,7 +52,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 +99,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 +128,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="")