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

kimi_cli/CHANGELOG.md

@@ -9,6 +9,21 @@ Internal builds may append content to the Unreleased section.
 Only write entries that are worth mentioning to users.
 -->
 
+## [0.42] - 2025-10-28
+
+### Added
+
+- Support Ctrl-J or Alt-Enter to insert a new line
+
+### Changed
+
+- Change mode switch shortcut from Ctrl-K to Ctrl-X
+- Improve overall robustness
+
+### Fixed
+
+- Fix ACP server `no attribute` error
+
 ## [0.41] - 2025-10-26
 
 ### Fixed

kimi_cli/__init__.py

@@ -1,125 +1,155 @@
 import contextlib
 import os
 import warnings
+from collections.abc import Generator
 from pathlib import Path
-from typing import Any, Literal
+from typing import Any
 
-import click
 from pydantic import SecretStr
 
 from kimi_cli.agentspec import DEFAULT_AGENT_FILE
-from kimi_cli.config import Config, LLMModel, LLMProvider
+from kimi_cli.config import LLMModel, LLMProvider, load_config
 from kimi_cli.llm import augment_provider_with_env_vars, create_llm
-from kimi_cli.metadata import Session
-from kimi_cli.soul.agent import load_agent_with_mcp
+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.globals import AgentGlobals
 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
 
-UIMode = Literal["shell", "print", "acp"]
-
-
-async def kimi_run(
-    *,
-    config: Config,
-    model_name: str | None,
-    work_dir: Path,
-    session: Session,
-    command: str | None = None,
-    agent_file: Path = DEFAULT_AGENT_FILE,
-    ui: UIMode = "shell",
-    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."""
-    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)
-        stream = ui != "print"  # use non-streaming mode only for print UI
-        llm = create_llm(provider, model, stream=stream, session_id=session.id)
-
-    agent_globals = await AgentGlobals.create(config, llm, session, yolo)
-    try:
-        agent = await load_agent_with_mcp(agent_file, agent_globals, mcp_configs or [])
-    except ValueError as e:
-        raise click.BadParameter(f"Failed to load agent: {e}") from e
-
-    if command is not None:
-        command = command.strip()
-        if not command:
-            raise click.BadParameter("Command cannot be empty")
-
-    context = Context(session.history_file)
-    await context.restore()
-
-    soul = KimiSoul(
-        agent,
-        agent_globals,
-        context=context,
-        loop_control=config.loop_control,
-    )
-
-    original_cwd = Path.cwd()
-    os.chdir(work_dir)
-
-    try:
-        if ui == "shell":
+
+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(
-                soul,
+                self._soul,
                 welcome_info={
-                    "Directory": str(work_dir),
-                    "Session": session.id,
+                    "Directory": str(self._session.work_dir),
+                    "Session": self._session.id,
                 },
             )
-            # to ignore possible warnings from dateparser
-            warnings.filterwarnings("ignore", category=DeprecationWarning)
-            with contextlib.redirect_stderr(StreamToLogger()):
-                return await app.run(command)
-        elif ui == "print":
-            soul._approval.set_yolo(True)  # print mode implies yolo mode
+            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(
-                soul,
-                input_format or "text",
-                output_format or "text",
-                context.file_backend,
+                self._soul,
+                input_format,
+                output_format,
+                self._session.history_file,
             )
             return await app.run(command)
-        elif ui == "acp":
-            if command is not None:
-                logger.warning("ACP server ignores command argument")
-            app = ACPServer(soul)
+
+    async def run_acp_server(self) -> bool:
+        with self._app_env():
+            app = ACPServer(self._soul)
             return await app.run()
-        else:
-            raise click.BadParameter(f"Invalid UI mode: {ui}")
-    finally:
-        os.chdir(original_cwd)

kimi_cli/agents/{koder → default}/agent.yaml

@@ -19,6 +19,6 @@ agent:
     - "kimi_cli.tools.web:SearchWeb"
     - "kimi_cli.tools.web:FetchURL"
   subagents:
-    koder:
+    coder:
       path: ./sub.yaml
       description: "Good at general software engineering tasks."

kimi_cli/agentspec.py

@@ -4,12 +4,14 @@ from typing import Any, NamedTuple
 import yaml
 from pydantic import BaseModel, Field
 
+from kimi_cli.exception import AgentSpecError
+
 
 def get_agents_dir() -> Path:
     return Path(__file__).parent / "agents"
 
 
-DEFAULT_AGENT_FILE = get_agents_dir() / "koder" / "agent.yaml"
+DEFAULT_AGENT_FILE = get_agents_dir() / "default" / "agent.yaml"
 
 
 class AgentSpec(BaseModel):
@@ -47,15 +49,21 @@ class ResolvedAgentSpec(NamedTuple):
 
 
 def load_agent_spec(agent_file: Path) -> ResolvedAgentSpec:
-    """Load agent specification from file."""
+    """
+    Load agent specification from file.
+
+    Raises:
+        FileNotFoundError: If the agent spec file is not found.
+        AgentSpecError: If the agent spec is not valid.
+    """
     agent_spec = _load_agent_spec(agent_file)
     assert agent_spec.extend is None, "agent extension should be recursively resolved"
     if agent_spec.name is None:
-        raise ValueError("Agent name is required")
+        raise AgentSpecError("Agent name is required")
     if agent_spec.system_prompt_path is None:
-        raise ValueError("System prompt path is required")
+        raise AgentSpecError("System prompt path is required")
     if agent_spec.tools is None:
-        raise ValueError("Tools are required")
+        raise AgentSpecError("Tools are required")
     return ResolvedAgentSpec(
         name=agent_spec.name,
         system_prompt_path=agent_spec.system_prompt_path,
@@ -68,12 +76,15 @@ def load_agent_spec(agent_file: Path) -> ResolvedAgentSpec:
 
 def _load_agent_spec(agent_file: Path) -> AgentSpec:
     assert agent_file.is_file(), "expect agent file to exist"
-    with open(agent_file, encoding="utf-8") as f:
-        data: dict[str, Any] = yaml.safe_load(f)
+    try:
+        with open(agent_file, encoding="utf-8") as f:
+            data: dict[str, Any] = yaml.safe_load(f)
+    except yaml.YAMLError as e:
+        raise AgentSpecError(f"Invalid YAML in agent spec file: {e}") from e
 
     version = data.get("version", 1)
     if version != 1:
-        raise ValueError(f"Unsupported agent spec version: {version}")
+        raise AgentSpecError(f"Unsupported agent spec version: {version}")
 
     agent_spec = AgentSpec(**data.get("agent", {}))
     if agent_spec.system_prompt_path is not None:

kimi_cli/cli.py

@@ -1,15 +1,15 @@
 import asyncio
 import json
 import sys
+from collections.abc import Callable
 from pathlib import Path
+from typing import Any, Literal, get_args
 
 import click
 
-from kimi_cli import UIMode, kimi_run
-from kimi_cli.agentspec import DEFAULT_AGENT_FILE
-from kimi_cli.config import ConfigError, load_config
+from kimi_cli import KimiCLI
 from kimi_cli.constant import VERSION
-from kimi_cli.metadata import continue_session, new_session
+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
@@ -21,6 +21,9 @@ class Reload(Exception):
     pass
 
 
+UIMode = Literal["shell", "print", "acp"]
+
+
 @click.command(context_settings=dict(help_option_names=["-h", "--help"]))
 @click.version_option(VERSION)
 @click.option(
@@ -38,8 +41,8 @@ class Reload(Exception):
 @click.option(
     "--agent-file",
     type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=Path),
-    default=DEFAULT_AGENT_FILE,
-    help="Custom agent specification file. Default: builtin Kimi Koder.",
+    default=None,
+    help="Custom agent specification file. Default: builtin default agent.",
 )
 @click.option(
     "--model",
@@ -77,7 +80,7 @@ class Reload(Exception):
 @click.option(
     "--ui",
     "ui",
-    type=click.Choice(["shell", "print", "acp"]),
+    type=click.Choice(get_args(UIMode)),
     default="shell",
     help="UI mode to use. Default: shell.",
 )
@@ -85,7 +88,7 @@ class Reload(Exception):
     "--print",
     "ui",
     flag_value="print",
-    help="Run in print mode. Shortcut for `--ui print`.",
+    help="Run in print mode. Shortcut for `--ui print`. Note: print mode implicitly adds `--yolo`.",
 )
 @click.option(
     "--acp",
@@ -95,7 +98,7 @@ class Reload(Exception):
 )
 @click.option(
     "--input-format",
-    type=click.Choice(["text", "stream-json"]),
+    type=click.Choice(get_args(InputFormat)),
     default=None,
     help=(
         "Input format to use. Must be used with `--print` "
@@ -105,7 +108,7 @@ class Reload(Exception):
 )
 @click.option(
     "--output-format",
-    type=click.Choice(["text", "stream-json"]),
+    type=click.Choice(get_args(OutputFormat)),
     default=None,
     help="Output format to use. Must be used with `--print`. Default: text.",
 )
@@ -140,7 +143,7 @@ class Reload(Exception):
 def kimi(
     verbose: bool,
     debug: bool,
-    agent_file: Path,
+    agent_file: Path | None,
     model_name: str | None,
     work_dir: Path,
     continue_: bool,
@@ -153,7 +156,11 @@ def kimi(
     yolo: bool,
 ):
     """Kimi, your next CLI agent."""
-    echo = click.echo if verbose else lambda *args, **kwargs: None
+
+    def _noop_echo(*args: Any, **kwargs: Any):
+        pass
+
+    echo: Callable[..., None] = click.echo if verbose else _noop_echo
 
     logger.add(
         get_share_dir() / "logs" / "kimi.log",
@@ -163,19 +170,23 @@ def kimi(
     )
 
     work_dir = work_dir.absolute()
-
     if continue_:
-        session = continue_session(work_dir)
+        session = Session.continue_(work_dir)
         if session is None:
             raise click.BadOptionUsage(
                 "--continue", "No previous session found for the working directory"
             )
         echo(f"✓ Continuing previous session: {session.id}")
     else:
-        session = new_session(work_dir)
+        session = Session.create(work_dir)
         echo(f"✓ Created new session: {session.id}")
     echo(f"✓ Session history file: {session.history_file}")
 
+    if command is not None:
+        command = command.strip()
+        if not command:
+            raise click.BadOptionUsage("--command", "Command cannot be empty")
+
     if input_format is not None and ui != "print":
         raise click.BadOptionUsage(
             "--input-format",
@@ -188,7 +199,7 @@ def kimi(
         )
 
     try:
-        mcp_configs = [json.loads(conf.read_text()) for conf in mcp_config_file]
+        mcp_configs = [json.loads(conf.read_text(encoding="utf-8")) for conf in mcp_config_file]
     except json.JSONDecodeError as e:
         raise click.BadOptionUsage("--mcp-config-file", f"Invalid JSON: {e}") from e
 
@@ -197,29 +208,32 @@ def kimi(
     except json.JSONDecodeError as e:
         raise click.BadOptionUsage("--mcp-config", f"Invalid JSON: {e}") from e
 
+    async def _run() -> bool:
+        instance = await KimiCLI.create(
+            session,
+            yolo=yolo or (ui == "print"),  # print mode implies yolo
+            stream=ui != "print",  # use non-streaming mode only for print UI
+            mcp_configs=mcp_configs,
+            model_name=model_name,
+            agent_file=agent_file,
+        )
+        match ui:
+            case "shell":
+                return await instance.run_shell_mode(command)
+            case "print":
+                return await instance.run_print_mode(
+                    input_format or "text",
+                    output_format or "text",
+                    command,
+                )
+            case "acp":
+                if command is not None:
+                    logger.warning("ACP server ignores command argument")
+                return await instance.run_acp_server()
+
     while True:
         try:
-            try:
-                config = load_config()
-            except ConfigError as e:
-                raise click.ClickException(f"Failed to load config: {e}") from e
-            echo(f"✓ Loaded config: {config}")
-
-            succeeded = asyncio.run(
-                kimi_run(
-                    config=config,
-                    model_name=model_name,
-                    work_dir=work_dir,
-                    session=session,
-                    command=command,
-                    agent_file=agent_file,
-                    ui=ui,
-                    input_format=input_format,
-                    output_format=output_format,
-                    mcp_configs=mcp_configs,
-                    yolo=yolo,
-                )
-            )
+            succeeded = asyncio.run(_run())
             if not succeeded:
                 sys.exit(1)
             break

kimi_cli/config.py

@@ -4,6 +4,7 @@ from typing import Literal, Self
 
 from pydantic import BaseModel, Field, SecretStr, ValidationError, field_serializer, model_validator
 
+from kimi_cli.exception import ConfigError
 from kimi_cli.share import get_share_dir
 from kimi_cli.utils.logging import logger
 
@@ -17,6 +18,8 @@ class LLMProvider(BaseModel):
     """API base URL"""
     api_key: SecretStr
     """API key"""
+    custom_headers: dict[str, str] = Field(default_factory=dict)
+    """Custom headers to include in API requests"""
 
     @field_serializer("api_key", when_used="json")
     def dump_secret(self, v: SecretStr):
@@ -50,6 +53,8 @@ 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 to include in API requests."""
 
     @field_serializer("api_key", when_used="json")
     def dump_secret(self, v: SecretStr):
@@ -99,13 +104,21 @@ def get_default_config() -> Config:
     )
 
 
-def load_config() -> Config:
-    """Load configuration from config file.
+def load_config(config_file: Path | None = None) -> Config:
+    """
+    Load configuration from config file.
+    If the config file does not exist, create it with default configuration.
+
+    Args:
+        config_file (Path | None): Path to the configuration file. If None, use default path.
 
     Returns:
         Validated Config object.
+
+    Raises:
+        ConfigError: If the configuration file is invalid.
     """
-    config_file = get_config_file()
+    config_file = config_file or get_config_file()
     logger.debug("Loading config from file: {file}", file=config_file)
 
     if not config_file.exists():
@@ -119,20 +132,21 @@ def load_config() -> Config:
         with open(config_file, encoding="utf-8") as f:
             data = json.load(f)
         return Config(**data)
-    except (json.JSONDecodeError, ValidationError) as e:
-        raise ConfigError(f"Invalid configuration file: {config_file}") from e
-
+    except json.JSONDecodeError as e:
+        raise ConfigError(f"Invalid JSON in configuration file: {e}") from e
+    except ValidationError as e:
+        raise ConfigError(f"Invalid configuration file: {e}") from e
 
-class ConfigError(Exception):
-    """Configuration error."""
-
-    def __init__(self, message: str):
-        super().__init__(message)
 
+def save_config(config: Config, config_file: Path | None = None):
+    """
+    Save configuration to config file.
 
-def save_config(config: Config):
-    """Save configuration to config file."""
-    config_file = get_config_file()
+    Args:
+        config (Config): Config object to save.
+        config_file (Path | None): Path to the configuration file. If None, use default path.
+    """
+    config_file = config_file or get_config_file()
     logger.debug("Saving config to file: {file}", file=config_file)
     with open(config_file, "w", encoding="utf-8") as f:
         f.write(config.model_dump_json(indent=2, exclude_none=True))

kimi_cli/exception.py

@@ -0,0 +1,16 @@
+class KimiCLIException(Exception):
+    """Base exception class for Kimi CLI."""
+
+    pass
+
+
+class ConfigError(KimiCLIException):
+    """Configuration error."""
+
+    pass
+
+
+class AgentSpecError(KimiCLIException):
+    """Agent specification error."""
+
+    pass

kimi_cli/llm.py

@@ -52,6 +52,7 @@ def create_llm(
                 stream=stream,
                 default_headers={
                     "User-Agent": USER_AGENT,
+                    **provider.custom_headers,
                 },
             )
             if session_id: