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

kimi_cli/CHANGELOG.md

@@ -9,6 +9,29 @@ Internal builds may append content to the Unreleased section.
 Only write entries that are worth mentioning to users.
 -->
 
+## [0.44] - 2025-10-30
+
+### Changed
+
+- Improve startup time
+
+### Fixed
+
+- Fix potential invalid bytes in user input
+
+## [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

@@ -1,155 +0,0 @@
-import contextlib
-import os
-import warnings
-from collections.abc import Generator
-from pathlib import Path
-from typing import Any
-
-from pydantic import SecretStr
-
-from kimi_cli.agentspec import DEFAULT_AGENT_FILE
-from kimi_cli.config import LLMModel, LLMProvider, load_config
-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.soul.context import Context
-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.utils.logging import StreamToLogger, logger
-
-
-class KimiCLI:
-    @staticmethod
-    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,
-        model_name: str | None = None,
-        agent_file: Path | 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.
-            model_name (str | None, optional): Name of the model to use. Defaults to None.
-            agent_file (Path | None, optional): Path to the agent file. 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.
-        """
-        config = load_config(config_file)
-        logger.info("Loaded config: {config}", config=config)
-
-        model: LLMModel | None = None
-        provider: LLMProvider | None = None
-
-        # try to use config file
-        if not model_name and config.default_model:
-            # no --model specified && default model is set in config
-            model = config.models[config.default_model]
-            provider = config.providers[model.provider]
-        if model_name and model_name in config.models:
-            # --model specified && model is set in config
-            model = config.models[model_name]
-            provider = config.providers[model.provider]
-
-        if not model:
-            model = LLMModel(provider="", model="", max_context_size=100_000)
-            provider = LLMProvider(type="kimi", base_url="", api_key=SecretStr(""))
-
-        # try overwrite with environment variables
-        assert provider is not None
-        assert model is not None
-        augment_provider_with_env_vars(provider, model)
-
-        if not provider.base_url or not model.model:
-            llm = None
-        else:
-            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)
-
-        runtime = await Runtime.create(config, llm, session, yolo)
-
-        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)
-        await context.restore()
-
-        soul = KimiSoul(
-            agent,
-            runtime,
-            context=context,
-        )
-        return KimiCLI(soul, session)
-
-    def __init__(self, soul: KimiSoul, session: Session) -> None:
-        self._soul = soul
-        self._session = session
-
-    @property
-    def soul(self) -> KimiSoul:
-        """Get the KimiSoul instance."""
-        return self._soul
-
-    @property
-    def session(self) -> Session:
-        """Get the Session instance."""
-        return self._session
-
-    @contextlib.contextmanager
-    def _app_env(self) -> Generator[None]:
-        original_cwd = Path.cwd()
-        os.chdir(self._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)
-
-    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,
-                },
-            )
-            return await app.run(command)
-
-    async def run_print_mode(
-        self,
-        input_format: InputFormat,
-        output_format: OutputFormat,
-        command: str | None = None,
-    ) -> bool:
-        with self._app_env():
-            app = PrintApp(
-                self._soul,
-                input_format,
-                output_format,
-                self._session.history_file,
-            )
-            return await app.run(command)
-
-    async def run_acp_server(self) -> bool:
-        with self._app_env():
-            app = ACPServer(self._soul)
-            return await app.run()

kimi_cli/app.py

@@ -0,0 +1,195 @@
+import contextlib
+import os
+import warnings
+from collections.abc import Generator
+from pathlib import Path
+from typing import Any
+
+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.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.soul.context import Context
+from kimi_cli.soul.kimisoul import KimiSoul
+from kimi_cli.soul.runtime import Runtime
+from kimi_cli.utils.logging import StreamToLogger, logger
+
+
+class KimiCLI:
+    @staticmethod
+    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,
+        model_name: str | None = None,
+        agent_file: Path | 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.
+            model_name (str | None, optional): Name of the model to use. Defaults to None.
+            agent_file (Path | None, optional): Path to the agent file. 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.
+        """
+        config = load_config(config_file)
+        logger.info("Loaded config: {config}", config=config)
+
+        model: LLMModel | None = None
+        provider: LLMProvider | None = None
+
+        # try to use config file
+        if not model_name and config.default_model:
+            # no --model specified && default model is set in config
+            model = config.models[config.default_model]
+            provider = config.providers[model.provider]
+        if model_name and model_name in config.models:
+            # --model specified && model is set in config
+            model = config.models[model_name]
+            provider = config.providers[model.provider]
+
+        if not model:
+            model = LLMModel(provider="", model="", max_context_size=100_000)
+            provider = LLMProvider(type="kimi", base_url="", api_key=SecretStr(""))
+
+        # try overwrite with environment variables
+        assert provider is not None
+        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:
+            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)
+
+        runtime = await Runtime.create(config, llm, session, yolo)
+
+        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)
+        await context.restore()
+
+        soul = KimiSoul(
+            agent,
+            runtime,
+            context=context,
+        )
+        return KimiCLI(soul, runtime, env_overrides)
+
+    def __init__(
+        self,
+        _soul: KimiSoul,
+        _runtime: Runtime,
+        _env_overrides: dict[str, str],
+    ) -> None:
+        self._soul = _soul
+        self._runtime = _runtime
+        self._env_overrides = _env_overrides
+
+    @property
+    def soul(self) -> KimiSoul:
+        """Get the KimiSoul instance."""
+        return self._soul
+
+    @property
+    def session(self) -> Session:
+        """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)
+        try:
+            # to ignore possible warnings from dateparser
+            warnings.filterwarnings("ignore", category=DeprecationWarning)
+            with contextlib.redirect_stderr(StreamToLogger()):
+                yield
+        finally:
+            os.chdir(original_cwd)
+
+    async def run_shell_mode(self, command: str | None = None) -> bool:
+        from kimi_cli.ui.shell import ShellApp, WelcomeInfoItem
+
+        welcome_info = [
+            WelcomeInfoItem(name="Directory", value=str(self._runtime.session.work_dir)),
+            WelcomeInfoItem(name="Session", value=self._runtime.session.id),
+        ]
+        if base_url := self._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 self._runtime.llm:
+            welcome_info.append(
+                WelcomeInfoItem(
+                    name="Model",
+                    value="not set, send /setup to configure",
+                    level=WelcomeInfoItem.Level.WARN,
+                )
+            )
+        elif "KIMI_MODEL_NAME" in self._env_overrides:
+            welcome_info.append(
+                WelcomeInfoItem(
+                    name="Model",
+                    value=f"{self._soul.model} (from KIMI_MODEL_NAME)",
+                    level=WelcomeInfoItem.Level.WARN,
+                )
+            )
+        else:
+            welcome_info.append(
+                WelcomeInfoItem(
+                    name="Model",
+                    value=self._soul.model,
+                    level=WelcomeInfoItem.Level.INFO,
+                )
+            )
+        with self._app_env():
+            app = ShellApp(self._soul, welcome_info=welcome_info)
+            return await app.run(command)
+
+    async def run_print_mode(
+        self,
+        input_format: InputFormat,
+        output_format: OutputFormat,
+        command: str | None = None,
+    ) -> bool:
+        from kimi_cli.ui.print import PrintApp
+
+        with self._app_env():
+            app = PrintApp(
+                self._soul,
+                input_format,
+                output_format,
+                self._runtime.session.history_file,
+            )
+            return await app.run(command)
+
+    async def run_acp_server(self) -> bool:
+        from kimi_cli.ui.acp import ACPServer
+
+        with self._app_env():
+            app = ACPServer(self._soul)
+            return await app.run()

kimi_cli/cli.py

@@ -7,12 +7,7 @@ from typing import Any, Literal, get_args
 
 import click
 
-from kimi_cli import KimiCLI
 from kimi_cli.constant import VERSION
-from kimi_cli.session import Session
-from kimi_cli.share import get_share_dir
-from kimi_cli.ui.print import InputFormat, OutputFormat
-from kimi_cli.utils.logging import logger
 
 
 class Reload(Exception):
@@ -22,6 +17,8 @@ class Reload(Exception):
 
 
 UIMode = Literal["shell", "print", "acp"]
+InputFormat = Literal["text", "stream-json"]
+OutputFormat = Literal["text", "stream-json"]
 
 
 @click.command(context_settings=dict(help_option_names=["-h", "--help"]))
@@ -156,6 +153,10 @@ def kimi(
     yolo: bool,
 ):
     """Kimi, your next CLI agent."""
+    from kimi_cli.app import KimiCLI
+    from kimi_cli.session import Session
+    from kimi_cli.share import get_share_dir
+    from kimi_cli.utils.logging import logger
 
     def _noop_echo(*args: Any, **kwargs: Any):
         pass

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

@@ -2,31 +2,49 @@ import os
 from typing import NamedTuple
 
 from kosong.base.chat_provider import ChatProvider
-from kosong.chat_provider.chaos import ChaosChatProvider, ChaosConfig
-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 +53,8 @@ def augment_provider_with_env_vars(provider: LLMProvider, model: LLMModel):
         case _:
             pass
 
+    return applied
+
 
 def create_llm(
     provider: LLMProvider,
@@ -45,6 +65,8 @@ def create_llm(
 ) -> LLM:
     match provider.type:
         case "kimi":
+            from kosong.chat_provider.kimi import Kimi
+
             chat_provider = Kimi(
                 model=model.model,
                 base_url=provider.base_url,
@@ -52,12 +74,14 @@ def create_llm(
                 stream=stream,
                 default_headers={
                     "User-Agent": USER_AGENT,
-                    **provider.custom_headers,
+                    **(provider.custom_headers or {}),
                 },
             )
             if session_id:
                 chat_provider = chat_provider.with_generation_kwargs(prompt_cache_key=session_id)
         case "openai_legacy":
+            from kosong.chat_provider.openai_legacy import OpenAILegacy
+
             chat_provider = OpenAILegacy(
                 model=model.model,
                 base_url=provider.base_url,
@@ -65,6 +89,8 @@ def create_llm(
                 stream=stream,
             )
         case "_chaos":
+            from kosong.chat_provider.chaos import ChaosChatProvider, ChaosConfig
+
             chat_provider = ChaosChatProvider(
                 model=model.model,
                 base_url=provider.base_url,
@@ -75,4 +101,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/agent.py

@@ -4,7 +4,6 @@ import string
 from pathlib import Path
 from typing import Any, NamedTuple
 
-import fastmcp
 from kosong.tooling import CallableTool, CallableTool2, Toolset
 
 from kimi_cli.agentspec import ResolvedAgentSpec, load_agent_spec
@@ -14,7 +13,6 @@ from kimi_cli.soul.approval import Approval
 from kimi_cli.soul.denwarenji import DenwaRenji
 from kimi_cli.soul.runtime import BuiltinSystemPromptArgs, Runtime
 from kimi_cli.soul.toolset import CustomToolset
-from kimi_cli.tools.mcp import MCPTool
 from kimi_cli.utils.logging import logger
 
 
@@ -143,6 +141,10 @@ async def _load_mcp_tools(
         ValueError: If the MCP config is not valid.
         RuntimeError: If the MCP server cannot be connected.
     """
+    import fastmcp
+
+    from kimi_cli.tools.mcp import MCPTool
+
     for mcp_config in mcp_configs:
         logger.info("Loading MCP tools from: {mcp_config}", mcp_config=mcp_config)
         client = fastmcp.Client(mcp_config)