kimi-cli-x 1.37.0__tar.gz

kimi_cli_x-1.37.0/PKG-INFO

@@ -0,0 +1,211 @@
+Metadata-Version: 2.3
+Name: kimi-cli-x
+Version: 1.37.0
+Summary: Kimi Code CLI is your next CLI agent.
+Requires-Dist: agent-client-protocol==0.8.0
+Requires-Dist: aiofiles>=24.0,<26.0
+Requires-Dist: aiohttp==3.13.3
+Requires-Dist: typer==0.21.1
+Requires-Dist: kosong==0.50.0
+Requires-Dist: loguru>=0.6.0,<0.8
+Requires-Dist: prompt-toolkit==3.0.52
+Requires-Dist: pillow==12.1.0
+Requires-Dist: pyyaml==6.0.3
+Requires-Dist: rich==14.2.0
+Requires-Dist: ripgrepy==2.2.0
+Requires-Dist: streamingjson==0.0.5
+Requires-Dist: trafilatura==2.0.0
+Requires-Dist: lxml==6.0.2
+Requires-Dist: tenacity
+Requires-Dist: fastmcp
+Requires-Dist: pydantic==2.13.2
+Requires-Dist: httpx[socks]==0.28.1
+Requires-Dist: pykaos==0.9.0
+Requires-Dist: batrachian-toad==0.5.23 ; python_full_version >= '3.14'
+Requires-Dist: tomlkit==0.14.0
+Requires-Dist: jinja2==3.1.6
+Requires-Dist: pyobjc-framework-cocoa>=12.1 ; sys_platform == 'darwin'
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: uvicorn[standard]>=0.32.0
+Requires-Dist: scalar-fastapi>=1.5.0
+Requires-Dist: websockets>=14.0
+Requires-Dist: keyring>=25.7.0
+Requires-Dist: setproctitle>=1.3.0
+Requires-Dist: demjson3
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# Kimi Code CLI
+
+[![Commit Activity](https://img.shields.io/github/commit-activity/w/MoonshotAI/kimi-cli)](https://github.com/MoonshotAI/kimi-cli/graphs/commit-activity)
+[![Checks](https://img.shields.io/github/check-runs/MoonshotAI/kimi-cli/main)](https://github.com/MoonshotAI/kimi-cli/actions)
+[![Version](https://img.shields.io/pypi/v/kimi-cli)](https://pypi.org/project/kimi-cli/)
+[![Downloads](https://img.shields.io/pypi/dw/kimi-cli)](https://pypistats.org/packages/kimi-cli)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/MoonshotAI/kimi-cli)
+
+[Kimi Code](https://www.kimi.com/code/) | [Documentation](https://moonshotai.github.io/kimi-cli/en/) | [文档](https://moonshotai.github.io/kimi-cli/zh/)
+
+Kimi Code CLI is an AI agent that runs in the terminal, helping you complete software development tasks and terminal operations. It can read and edit code, execute shell commands, search and fetch web pages, and autonomously plan and adjust actions during execution.
+
+## Getting Started
+
+See [Getting Started](https://moonshotai.github.io/kimi-cli/en/guides/getting-started.html) for how to install and start using Kimi Code CLI.
+
+## Key Features
+
+### Shell command mode
+
+Kimi Code CLI is not only a coding agent, but also a shell. You can switch the shell command mode by pressing `Ctrl-X`. In this mode, you can directly run shell commands without leaving Kimi Code CLI.
+
+![](./docs/media/shell-mode.gif)
+
+> [!NOTE]
+> Built-in shell commands like `cd` are not supported yet.
+
+### VS Code extension
+
+Kimi Code CLI can be integrated with [Visual Studio Code](https://code.visualstudio.com/) via the [Kimi Code VS Code Extension](https://marketplace.visualstudio.com/items?itemName=moonshot-ai.kimi-code).
+
+![VS Code Extension](./docs/media/vscode.png)
+
+### IDE integration via ACP
+
+Kimi Code CLI supports [Agent Client Protocol] out of the box. You can use it together with any ACP-compatible editor or IDE.
+
+[Agent Client Protocol]: https://github.com/agentclientprotocol/agent-client-protocol
+
+To use Kimi Code CLI with ACP clients, make sure to run Kimi Code CLI in the terminal and send `/login` to complete the login first. Then, you can configure your ACP client to start Kimi Code CLI as an ACP agent server with command `kimi acp`.
+
+For example, to use Kimi Code CLI with [Zed](https://zed.dev/) or [JetBrains](https://blog.jetbrains.com/ai/2025/12/bring-your-own-ai-agent-to-jetbrains-ides/), add the following configuration to your `~/.config/zed/settings.json` or `~/.jetbrains/acp.json` file:
+
+```json
+{
+  "agent_servers": {
+    "Kimi Code CLI": {
+      "type": "custom",
+      "command": "kimi",
+      "args": ["acp"],
+      "env": {}
+    }
+  }
+}
+```
+
+Then you can create Kimi Code CLI threads in IDE's agent panel.
+
+![](./docs/media/acp-integration.gif)
+
+### Zsh integration
+
+You can use Kimi Code CLI together with Zsh, to empower your shell experience with AI agent capabilities.
+
+Install the [zsh-kimi-cli](https://github.com/MoonshotAI/zsh-kimi-cli) plugin via:
+
+```sh
+git clone https://github.com/MoonshotAI/zsh-kimi-cli.git \
+  ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/kimi-cli
+```
+
+> [!NOTE]
+> If you are using a plugin manager other than Oh My Zsh, you may need to refer to the plugin's README for installation instructions.
+
+Then add `kimi-cli` to your Zsh plugin list in `~/.zshrc`:
+
+```sh
+plugins=(... kimi-cli)
+```
+
+After restarting Zsh, you can switch to agent mode by pressing `Ctrl-X`.
+
+### MCP support
+
+Kimi Code CLI supports MCP (Model Context Protocol) tools.
+
+**`kimi mcp` sub-command group**
+
+You can manage MCP servers with `kimi mcp` sub-command group. For example:
+
+```sh
+# Add streamable HTTP server:
+kimi mcp add --transport http context7 https://mcp.context7.com/mcp --header "CONTEXT7_API_KEY: ctx7sk-your-key"
+
+# Add streamable HTTP server with OAuth authorization:
+kimi mcp add --transport http --auth oauth linear https://mcp.linear.app/mcp
+
+# Add stdio server:
+kimi mcp add --transport stdio chrome-devtools -- npx chrome-devtools-mcp@latest
+
+# List added MCP servers:
+kimi mcp list
+
+# Remove an MCP server:
+kimi mcp remove chrome-devtools
+
+# Authorize an MCP server:
+kimi mcp auth linear
+```
+
+**Ad-hoc MCP configuration**
+
+Kimi Code CLI also supports ad-hoc MCP server configuration via CLI option.
+
+Given an MCP config file in the well-known MCP config format like the following:
+
+```json
+{
+  "mcpServers": {
+    "context7": {
+      "url": "https://mcp.context7.com/mcp",
+      "headers": {
+        "CONTEXT7_API_KEY": "YOUR_API_KEY"
+      }
+    },
+    "chrome-devtools": {
+      "command": "npx",
+      "args": ["-y", "chrome-devtools-mcp@latest"]
+    }
+  }
+}
+```
+
+Run `kimi` with `--mcp-config-file` option to connect to the specified MCP servers:
+
+```sh
+kimi --mcp-config-file /path/to/mcp.json
+```
+
+### More
+
+See more features in the [Documentation](https://moonshotai.github.io/kimi-cli/en/).
+
+## Development
+
+To develop Kimi Code CLI, run:
+
+```sh
+git clone https://github.com/MoonshotAI/kimi-cli.git
+cd kimi-cli
+
+make prepare  # prepare the development environment
+```
+
+Then you can start working on Kimi Code CLI.
+
+Refer to the following commands after you make changes:
+
+```sh
+uv run kimi  # run Kimi Code CLI
+
+make format  # format code
+make check  # run linting and type checking
+make test  # run tests
+make test-kimi-cli  # run Kimi Code CLI tests only
+make test-kosong  # run kosong tests only
+make test-pykaos  # run pykaos tests only
+make build-web  # build the web UI and sync it into the package (requires Node.js/npm)
+make build  # build python packages
+make build-bin  # build standalone binary
+make help  # show all make targets
+```
+
+Note: `make build` and `make build-bin` automatically run `make build-web` to embed the web UI.

kimi_cli_x-1.37.0/README.md

@@ -0,0 +1,174 @@
+# Kimi Code CLI
+
+[![Commit Activity](https://img.shields.io/github/commit-activity/w/MoonshotAI/kimi-cli)](https://github.com/MoonshotAI/kimi-cli/graphs/commit-activity)
+[![Checks](https://img.shields.io/github/check-runs/MoonshotAI/kimi-cli/main)](https://github.com/MoonshotAI/kimi-cli/actions)
+[![Version](https://img.shields.io/pypi/v/kimi-cli)](https://pypi.org/project/kimi-cli/)
+[![Downloads](https://img.shields.io/pypi/dw/kimi-cli)](https://pypistats.org/packages/kimi-cli)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/MoonshotAI/kimi-cli)
+
+[Kimi Code](https://www.kimi.com/code/) | [Documentation](https://moonshotai.github.io/kimi-cli/en/) | [文档](https://moonshotai.github.io/kimi-cli/zh/)
+
+Kimi Code CLI is an AI agent that runs in the terminal, helping you complete software development tasks and terminal operations. It can read and edit code, execute shell commands, search and fetch web pages, and autonomously plan and adjust actions during execution.
+
+## Getting Started
+
+See [Getting Started](https://moonshotai.github.io/kimi-cli/en/guides/getting-started.html) for how to install and start using Kimi Code CLI.
+
+## Key Features
+
+### Shell command mode
+
+Kimi Code CLI is not only a coding agent, but also a shell. You can switch the shell command mode by pressing `Ctrl-X`. In this mode, you can directly run shell commands without leaving Kimi Code CLI.
+
+![](./docs/media/shell-mode.gif)
+
+> [!NOTE]
+> Built-in shell commands like `cd` are not supported yet.
+
+### VS Code extension
+
+Kimi Code CLI can be integrated with [Visual Studio Code](https://code.visualstudio.com/) via the [Kimi Code VS Code Extension](https://marketplace.visualstudio.com/items?itemName=moonshot-ai.kimi-code).
+
+![VS Code Extension](./docs/media/vscode.png)
+
+### IDE integration via ACP
+
+Kimi Code CLI supports [Agent Client Protocol] out of the box. You can use it together with any ACP-compatible editor or IDE.
+
+[Agent Client Protocol]: https://github.com/agentclientprotocol/agent-client-protocol
+
+To use Kimi Code CLI with ACP clients, make sure to run Kimi Code CLI in the terminal and send `/login` to complete the login first. Then, you can configure your ACP client to start Kimi Code CLI as an ACP agent server with command `kimi acp`.
+
+For example, to use Kimi Code CLI with [Zed](https://zed.dev/) or [JetBrains](https://blog.jetbrains.com/ai/2025/12/bring-your-own-ai-agent-to-jetbrains-ides/), add the following configuration to your `~/.config/zed/settings.json` or `~/.jetbrains/acp.json` file:
+
+```json
+{
+  "agent_servers": {
+    "Kimi Code CLI": {
+      "type": "custom",
+      "command": "kimi",
+      "args": ["acp"],
+      "env": {}
+    }
+  }
+}
+```
+
+Then you can create Kimi Code CLI threads in IDE's agent panel.
+
+![](./docs/media/acp-integration.gif)
+
+### Zsh integration
+
+You can use Kimi Code CLI together with Zsh, to empower your shell experience with AI agent capabilities.
+
+Install the [zsh-kimi-cli](https://github.com/MoonshotAI/zsh-kimi-cli) plugin via:
+
+```sh
+git clone https://github.com/MoonshotAI/zsh-kimi-cli.git \
+  ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/kimi-cli
+```
+
+> [!NOTE]
+> If you are using a plugin manager other than Oh My Zsh, you may need to refer to the plugin's README for installation instructions.
+
+Then add `kimi-cli` to your Zsh plugin list in `~/.zshrc`:
+
+```sh
+plugins=(... kimi-cli)
+```
+
+After restarting Zsh, you can switch to agent mode by pressing `Ctrl-X`.
+
+### MCP support
+
+Kimi Code CLI supports MCP (Model Context Protocol) tools.
+
+**`kimi mcp` sub-command group**
+
+You can manage MCP servers with `kimi mcp` sub-command group. For example:
+
+```sh
+# Add streamable HTTP server:
+kimi mcp add --transport http context7 https://mcp.context7.com/mcp --header "CONTEXT7_API_KEY: ctx7sk-your-key"
+
+# Add streamable HTTP server with OAuth authorization:
+kimi mcp add --transport http --auth oauth linear https://mcp.linear.app/mcp
+
+# Add stdio server:
+kimi mcp add --transport stdio chrome-devtools -- npx chrome-devtools-mcp@latest
+
+# List added MCP servers:
+kimi mcp list
+
+# Remove an MCP server:
+kimi mcp remove chrome-devtools
+
+# Authorize an MCP server:
+kimi mcp auth linear
+```
+
+**Ad-hoc MCP configuration**
+
+Kimi Code CLI also supports ad-hoc MCP server configuration via CLI option.
+
+Given an MCP config file in the well-known MCP config format like the following:
+
+```json
+{
+  "mcpServers": {
+    "context7": {
+      "url": "https://mcp.context7.com/mcp",
+      "headers": {
+        "CONTEXT7_API_KEY": "YOUR_API_KEY"
+      }
+    },
+    "chrome-devtools": {
+      "command": "npx",
+      "args": ["-y", "chrome-devtools-mcp@latest"]
+    }
+  }
+}
+```
+
+Run `kimi` with `--mcp-config-file` option to connect to the specified MCP servers:
+
+```sh
+kimi --mcp-config-file /path/to/mcp.json
+```
+
+### More
+
+See more features in the [Documentation](https://moonshotai.github.io/kimi-cli/en/).
+
+## Development
+
+To develop Kimi Code CLI, run:
+
+```sh
+git clone https://github.com/MoonshotAI/kimi-cli.git
+cd kimi-cli
+
+make prepare  # prepare the development environment
+```
+
+Then you can start working on Kimi Code CLI.
+
+Refer to the following commands after you make changes:
+
+```sh
+uv run kimi  # run Kimi Code CLI
+
+make format  # format code
+make check  # run linting and type checking
+make test  # run tests
+make test-kimi-cli  # run Kimi Code CLI tests only
+make test-kosong  # run kosong tests only
+make test-pykaos  # run pykaos tests only
+make build-web  # build the web UI and sync it into the package (requires Node.js/npm)
+make build  # build python packages
+make build-bin  # build standalone binary
+make help  # show all make targets
+```
+
+Note: `make build` and `make build-bin` automatically run `make build-web` to embed the web UI.

kimi_cli_x-1.37.0/pyproject.toml

@@ -0,0 +1,117 @@
+[project]
+name = "kimi-cli-x"
+version = "1.37.0"
+description = "Kimi Code CLI is your next CLI agent."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "agent-client-protocol==0.8.0",
+    "aiofiles>=24.0,<26.0",
+    "aiohttp==3.13.3",
+    "typer==0.21.1",
+    "kosong==0.50.0",
+    # loguru stays >=0.6.0 because notify-py (via batrachian-toad) caps it at <=0.6.0 on 3.14+.
+    "loguru>=0.6.0,<0.8",
+    "prompt-toolkit==3.0.52",
+    "pillow==12.1.0",
+    "pyyaml==6.0.3",
+    "rich==14.2.0",
+    "ripgrepy==2.2.0",
+    "streamingjson==0.0.5",
+    "trafilatura==2.0.0",
+    # lxml is used by trafilatura/htmldate/justext; keep pinned for binary wheels.
+    "lxml==6.0.2",
+    "tenacity",
+    "fastmcp",
+    "pydantic==2.13.2",
+    "httpx[socks]==0.28.1",
+    "pykaos==0.9.0",
+    "batrachian-toad==0.5.23; python_version >= \"3.14\"",
+    "tomlkit==0.14.0",
+    "jinja2==3.1.6",
+    "pyobjc-framework-cocoa>=12.1 ; sys_platform == 'darwin'",
+    "fastapi>=0.115.0",
+    "uvicorn[standard]>=0.32.0",
+    "scalar-fastapi>=1.5.0",
+    "websockets>=14.0",
+    "keyring>=25.7.0",
+    "setproctitle>=1.3.0",
+    "demjson3",
+]
+
+[dependency-groups]
+dev = [
+    "pyinstaller==6.18.0",
+    "inline-snapshot[black]>=0.31.1",
+    "pyright>=1.1.407",
+    "ty>=0.0.9",
+    "pytest>=9.0.2",
+    "pytest-asyncio>=1.3.0",
+    "ruff>=0.14.10",
+]
+
+[build-system]
+requires = ["uv_build>=0.8.5,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = ["kimi_cli"]
+source-exclude = ["examples/**/*", "tests/**/*", "src/kimi_cli/deps/**/*"]
+
+[tool.uv.sources]
+kosong = { workspace = true }
+pykaos = { workspace = true }
+kimi-cli = { workspace = true }
+
+[project.scripts]
+kimi = "kimi_cli.__main__:main"
+kimi-cli = "kimi_cli.__main__:main"
+
+[tool.ruff]
+line-length = 100
+
+[tool.ruff.lint]
+select = [
+    "E",   # pycodestyle
+    "F",   # Pyflakes
+    "UP",  # pyupgrade
+    "B",   # flake8-bugbear
+    "SIM", # flake8-simplify
+    "I",   # isort
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*.py" = ["E501"]
+"tests_e2e/**/*.py" = ["E501"]
+"src/kimi_cli/web/api/**/*.py" = ["B008"]  # FastAPI Depends() is standard usage
+
+[tool.pyright]
+typeCheckingMode = "standard"
+pythonVersion = "3.14"
+include = [
+    "src/**/*.py",
+    "tests/**/*.py",
+    "tests_ai/scripts/**/*.py",
+    "tests_e2e/**/*.py",
+]
+strict = ["src/kimi_cli/**/*.py"]
+
+[tool.ty.environment]
+python-version = "3.14"
+
+[tool.ty.src]
+include = [
+    "src/**/*.py",
+    "tests/**/*.py",
+    "tests_ai/scripts/**/*.py",
+    "tests_e2e/**/*.py",
+]
+
+[tool.typos.files]
+extend-exclude = ["kimi.spec", "pyinstaller.py"]
+
+[tool.typos.default.extend-words]
+datas = "datas"
+Seeked = "Seeked"
+seeked = "seeked"
+iterm = "iterm"

kimi_cli_x-1.37.0/src/kimi_cli/CHANGELOG.md

@@ -0,0 +1 @@
+../../CHANGELOG.md

kimi_cli_x-1.37.0/src/kimi_cli/__init__.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+
+class _LazyLogger:
+    """Import loguru only when logging is actually used."""
+
+    def __init__(self) -> None:
+        self._logger: Any | None = None
+
+    def _get(self) -> Any:
+        if self._logger is None:
+            from loguru import logger as real_logger
+
+            # Disable logging by default for library usage.
+            # Application entry points (e.g., kimi_cli.cli) should call logger.enable("kimi_cli")
+            # to enable logging.
+            real_logger.disable("kimi_cli")
+            self._logger = real_logger
+        return self._logger
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._get(), name)
+
+
+logger = cast(Any, _LazyLogger())
+
+__all__ = ["logger"]

kimi_cli_x-1.37.0/src/kimi_cli/__main__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+
+def _prog_name() -> str:
+    return Path(sys.argv[0]).name or "kimi"
+
+
+def main(argv: Sequence[str] | None = None) -> int | str | None:
+    from kimi_cli.utils.proxy import normalize_proxy_env
+
+    normalize_proxy_env()
+
+    args = list(sys.argv[1:] if argv is None else argv)
+
+    if len(args) == 1 and args[0] in {"--version", "-V"}:
+        from kimi_cli.constant import get_version
+
+        print(f"kimi, version {get_version()}")
+        return 0
+
+    from kimi_cli.cli import cli
+
+    try:
+        return cli(args=args, prog_name=_prog_name())
+    except SystemExit as exc:
+        return exc.code
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

kimi_cli_x-1.37.0/src/kimi_cli/acp/AGENTS.md

@@ -0,0 +1,92 @@
+# ACP Integration Notes (kimi-cli)
+
+## Protocol summary (ACP overview)
+- ACP is JSON-RPC 2.0 with request/response methods plus one-way notifications.
+- Typical flow: `initialize` -> optional `authenticate` -> `session/new` or `session/load`
+  -> `session/prompt`
+  with `session/update` notifications and optional `session/cancel`.
+- Clients provide `session/request_permission` and optional terminal/filesystem methods.
+- All ACP file paths must be absolute; line numbers are 1-based.
+
+## Entry points and server modes
+- **Single-session server**: `KimiCLI.run_acp()` uses `ACP` -> `ACPServerSingleSession`.
+  - Code: `src/kimi_cli/app.py`, `src/kimi_cli/ui/acp/__init__.py`.
+  - Used when running CLI with `--acp` UI mode.
+- **Multi-session server**: `acp_main()` runs `ACPServer` with `use_unstable_protocol=True`.
+  - Code: `src/kimi_cli/acp/__init__.py`, `src/kimi_cli/acp/server.py`.
+  - Exposed via the `kimi acp` command in `src/kimi_cli/cli/__init__.py`.
+
+## Capabilities advertised
+- `prompt_capabilities`: `embedded_context=False`, `image=True`, `audio=False`.
+- `mcp_capabilities`: `http=True`, `sse=False`.
+- Single-session: `load_session=False`, no session list capabilities.
+- Multi-session: `load_session=True`, `session_capabilities.list` supported.
+- `auth_methods=[]` (no authentication methods advertised).
+
+## Session lifecycle (implemented behavior)
+- `session/new`
+  - Multi-session: creates a persisted `Session`, builds `KimiCLI`, stores `ACPSession`.
+  - Single-session: wraps the existing `Soul` into a `Wire` loop and creates `ACPSession`.
+  - Both send `AvailableCommandsUpdate` for slash commands on session creation.
+  - MCP servers passed by ACP are converted via `acp_mcp_servers_to_mcp_config`.
+- `session/load`
+  - Multi-session only: loads by `Session.find`, then builds `KimiCLI` and `ACPSession`.
+  - No history replay yet (TODO).
+  - Single-session: not implemented.
+- `session/list`
+  - Multi-session only: lists sessions via `Session.list`, no pagination.
+  - Single-session: not implemented.
+- `session/prompt`
+  - Uses `ACPSession.prompt()` to stream updates and produce a `stop_reason`.
+  - Stop reasons: `end_turn`, `max_turn_requests`, `cancelled`.
+- `session/cancel`
+  - Sets the per-turn cancel event to stop the prompt.
+
+## Streaming updates and content mapping
+- Text chunks -> `AgentMessageChunk`.
+- Think chunks -> `AgentThoughtChunk`.
+- Tool calls:
+  - Start -> `ToolCallStart` with JSON args as text content.
+  - Streaming args -> `ToolCallProgress` with updated title/args.
+  - Results -> `ToolCallProgress` with `completed` or `failed`.
+  - Tool call IDs are prefixed with turn ID to avoid collisions across turns.
+- Plan updates:
+  - `TodoDisplayBlock` is converted into `AgentPlanUpdate`.
+- Available commands:
+  - `AvailableCommandsUpdate` is sent right after session creation.
+
+## Prompt/content conversion
+- Incoming prompt blocks:
+  - Supported: `TextContentBlock`, `ImageContentBlock` (converted to data URL).
+  - Unsupported types are logged and ignored.
+- Tool result display blocks:
+  - `DiffDisplayBlock` -> `FileEditToolCallContent`.
+  - `HideOutputDisplayBlock` suppresses tool output in ACP (used by terminal tool).
+
+## Tool integration and permission flow
+- ACP sessions use `ACPKaos` to route filesystem reads/writes through ACP clients.
+- If the client advertises `terminal` capability, the `Shell` tool is replaced by an
+  ACP-backed `Terminal` tool.
+  - Uses ACP `terminal/create`, waits for exit, streams `TerminalToolCallContent`,
+    then releases the terminal handle.
+- Approval requests in the core tool system are bridged to ACP
+  `session/request_permission` with allow-once/allow-always/reject options.
+
+## Current gaps / not implemented
+- `authenticate` method (not used by current Zed ACP client).
+- `session/set_mode` and `session/set_model` (no multi-mode/model switching in kimi-cli).
+- `ext_method` / `ext_notification` for custom ACP extensions are stubbed.
+- Single-session server does not implement `session/load` or `session/list`.
+
+## Filesystem (ACP client-backed)
+- When the client advertises `fs.readTextFile` / `fs.writeTextFile`, `ACPKaos` routes
+  reads and writes through ACP `fs/*` methods.
+- `ReadFile` uses `KaosPath.read_lines`, which `ACPKaos` implements via ACP reads.
+- `ReadMediaFile` uses `KaosPath.read_bytes` to load image/video payloads through ACP reads.
+- `WriteFile` uses `KaosPath.read_text/write_text/append_text` and still generates diffs
+  and approvals in the tool layer.
+
+## Zed-specific notes (as of current integration)
+- Zed does not currently call `authenticate`.
+- Zed’s external agent server session management is not yet available, so
+  `session/load` is not exercised in practice.

kimi_cli_x-1.37.0/src/kimi_cli/acp/__init__.py

@@ -0,0 +1,13 @@
+def acp_main() -> None:
+    """Entry point for the multi-session ACP server."""
+    import asyncio
+
+    import acp
+
+    from kimi_cli.acp.server import ACPServer
+    from kimi_cli.app import enable_logging
+    from kimi_cli.utils.logging import logger
+
+    enable_logging()
+    logger.info("Starting ACP server on stdio")
+    asyncio.run(acp.run_agent(ACPServer(), use_unstable_protocol=True))