kimi-cli 0.45__py3-none-any.whl → 0.46__py3-none-any.whl

kimi_cli/CHANGELOG.md

@@ -9,6 +9,17 @@ Internal builds may append content to the Unreleased section.
 Only write entries that are worth mentioning to users.
 -->
 
+## [0.46] - 2025-11-03
+
+### Added
+
+- Introduce Wire over stdio for local IPC (experimental, subject to change)
+- Support Anthropic provider type
+
+### Fixed
+
+- Fix binary packed by PyInstaller not working due to wrong entrypoint
+
 ## [0.45] - 2025-10-31
 
 ### Added

kimi_cli/app.py

@@ -193,3 +193,10 @@ class KimiCLI:
         with self._app_env():
             app = ACPServer(self._soul)
             return await app.run()
+
+    async def run_wire_server(self) -> bool:
+        from kimi_cli.ui.wire import WireServer
+
+        with self._app_env():
+            server = WireServer(self._soul)
+            return await server.run()

kimi_cli/cli.py

@@ -16,7 +16,7 @@ class Reload(Exception):
     pass
 
 
-UIMode = Literal["shell", "print", "acp"]
+UIMode = Literal["shell", "print", "acp", "wire"]
 InputFormat = Literal["text", "stream-json"]
 OutputFormat = Literal["text", "stream-json"]
 
@@ -170,9 +170,12 @@ def kimi(
 
     echo: Callable[..., None] = click.echo if verbose else _noop_echo
 
+    if debug:
+        logger.enable("kosong")
     logger.add(
         get_share_dir() / "logs" / "kimi.log",
-        level="DEBUG" if debug else "INFO",
+        # FIXME: configure level for different modules
+        level="TRACE" if debug else "INFO",
         rotation="06:00",
         retention="10 days",
     )
@@ -238,6 +241,10 @@ def kimi(
                 if command is not None:
                     logger.warning("ACP server ignores command argument")
                 return await instance.run_acp_server()
+            case "wire":
+                if command is not None:
+                    logger.warning("Wire server ignores command argument")
+                return await instance.run_wire_server()
 
     while True:
         try:

kimi_cli/config.py

@@ -12,7 +12,7 @@ from kimi_cli.utils.logging import logger
 class LLMProvider(BaseModel):
     """LLM provider configuration."""
 
-    type: Literal["kimi", "openai_legacy", "openai_responses", "_chaos"]
+    type: Literal["kimi", "openai_legacy", "openai_responses", "anthropic", "_chaos"]
     """Provider type"""
     base_url: str
     """API base URL"""

kimi_cli/llm.py

@@ -105,6 +105,20 @@ def create_llm(
                 api_key=provider.api_key.get_secret_value(),
                 stream=stream,
             )
+        case "anthropic":
+            from kosong.chat_provider.anthropic import Anthropic
+
+            chat_provider = Anthropic(
+                model=model.model,
+                base_url=provider.base_url,
+                api_key=provider.api_key.get_secret_value(),
+                stream=stream,
+                default_max_tokens=50000,
+            ).with_generation_kwargs(
+                # TODO: support configurable values
+                thinking={"type": "enabled", "budget_tokens": 1024},
+                beta_features=["interleaved-thinking-2025-05-14"],
+            )
         case "_chaos":
             from kosong.chat_provider.chaos import ChaosChatProvider, ChaosConfig
 

kimi_cli/soul/toolset.py

@@ -2,7 +2,8 @@ from contextvars import ContextVar
 from typing import override
 
 from kosong.base.message import ToolCall
-from kosong.tooling import HandleResult, SimpleToolset
+from kosong.tooling import HandleResult
+from kosong.tooling.simple import SimpleToolset
 
 current_tool_call = ContextVar[ToolCall | None]("current_tool_call", default=None)
 

kimi_cli/tools/__init__.py

@@ -1,7 +1,8 @@
 import json
 from pathlib import Path
+from typing import cast
 
-import streamingjson
+import streamingjson  # pyright: ignore[reportMissingTypeStubs]
 from kosong.utils.typing import JsonType
 
 from kimi_cli.utils.string import shorten_middle
@@ -29,15 +30,15 @@ def extract_subtitle(lexer: streamingjson.Lexer, tool_name: str) -> str | None:
         case "SetTodoList":
             if not isinstance(curr_args, dict) or not curr_args.get("todos"):
                 return None
-            if not isinstance(curr_args["todos"], list):
+
+            from kimi_cli.tools.todo import Params
+
+            try:
+                todo_params = Params.model_validate(curr_args)
+                for todo in todo_params.todos:
+                    subtitle += f"• {todo.title} [{todo.status}]\n"
+            except Exception:
                 return None
-            for todo in curr_args["todos"]:
-                if not isinstance(todo, dict) or not todo.get("title"):
-                    continue
-                subtitle += f"• {todo['title']}"
-                if todo.get("status"):
-                    subtitle += f" [{todo['status']}]"
-                subtitle += "\n"
             return "\n" + subtitle.strip()
         case "Bash":
             if not isinstance(curr_args, dict) or not curr_args.get("command"):
@@ -72,7 +73,9 @@ def extract_subtitle(lexer: streamingjson.Lexer, tool_name: str) -> str | None:
                 return None
             subtitle = str(curr_args["url"])
         case _:
-            subtitle = "".join(lexer.json_content)
+            # lexer.json_content is list[str] based on streamingjson source code
+            content: list[str] = cast(list[str], lexer.json_content)  # pyright: ignore[reportUnknownMemberType]
+            subtitle = "".join(content)
     if tool_name not in ["SetTodoList"]:
         subtitle = shorten_middle(subtitle, width=50)
     return subtitle

kimi_cli/tools/bash/__init__.py

@@ -1,6 +1,7 @@
 import asyncio
+from collections.abc import Callable
 from pathlib import Path
-from typing import override
+from typing import Any, override
 
 from kosong.tooling import CallableTool2, ToolReturnType
 from pydantic import BaseModel, Field
@@ -29,7 +30,7 @@ class Bash(CallableTool2[Params]):
     description: str = load_desc(Path(__file__).parent / "bash.md", {})
     params: type[Params] = Params
 
-    def __init__(self, approval: Approval, **kwargs):
+    def __init__(self, approval: Approval, **kwargs: Any):
         super().__init__(**kwargs)
         self._approval = approval
 
@@ -71,8 +72,13 @@ class Bash(CallableTool2[Params]):
             )
 
 
-async def _stream_subprocess(command: str, stdout_cb, stderr_cb, timeout: int) -> int:
-    async def _read_stream(stream, cb):
+async def _stream_subprocess(
+    command: str,
+    stdout_cb: Callable[[bytes], None],
+    stderr_cb: Callable[[bytes], None],
+    timeout: int,
+) -> int:
+    async def _read_stream(stream: asyncio.StreamReader, cb: Callable[[bytes], None]):
         while True:
             line = await stream.readline()
             if line:
@@ -85,6 +91,9 @@ async def _stream_subprocess(command: str, stdout_cb, stderr_cb, timeout: int) -
         command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
     )
 
+    assert process.stdout is not None, "stdout is None"
+    assert process.stderr is not None, "stderr is None"
+
     try:
         await asyncio.wait_for(
             asyncio.gather(

kimi_cli/tools/dmail/__init__.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import override
+from typing import Any, override
 
 from kosong.tooling import CallableTool2, ToolError, ToolReturnType
 
@@ -8,12 +8,12 @@ from kimi_cli.soul.denwarenji import DenwaRenji, DenwaRenjiError, DMail
 NAME = "SendDMail"
 
 
-class SendDMail(CallableTool2):
+class SendDMail(CallableTool2[DMail]):
     name: str = NAME
     description: str = (Path(__file__).parent / "dmail.md").read_text(encoding="utf-8")
     params: type[DMail] = DMail
 
-    def __init__(self, denwa_renji: DenwaRenji, **kwargs):
+    def __init__(self, denwa_renji: DenwaRenji, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self._denwa_renji = denwa_renji
 

kimi_cli/tools/file/glob.py

@@ -2,7 +2,7 @@
 
 import asyncio
 from pathlib import Path
-from typing import override
+from typing import Any, override
 
 import aiofiles.os
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
@@ -38,7 +38,7 @@ class Glob(CallableTool2[Params]):
     )
     params: type[Params] = Params
 
-    def __init__(self, builtin_args: BuiltinSystemPromptArgs, **kwargs):
+    def __init__(self, builtin_args: BuiltinSystemPromptArgs, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self._work_dir = builtin_args.KIMI_WORK_DIR
 

kimi_cli/tools/file/grep.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from typing import override
 
 import aiohttp
-import ripgrepy
+import ripgrepy  # pyright: ignore[reportMissingTypeStubs]
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
 

kimi_cli/tools/file/patch.py

@@ -1,8 +1,8 @@
 from pathlib import Path
-from typing import override
+from typing import Any, Literal, override
 
 import aiofiles
-import patch_ng
+import patch_ng  # pyright: ignore[reportMissingTypeStubs]
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
 
@@ -12,6 +12,36 @@ from kimi_cli.tools.file import FileActions
 from kimi_cli.tools.utils import ToolRejectedError
 
 
+def _parse_patch(diff_bytes: bytes) -> patch_ng.PatchSet | None:
+    """Parse patch from bytes, returning PatchSet or None on error.
+
+    This wrapper provides type hints for the untyped patch_ng.fromstring function.
+    """
+    result: patch_ng.PatchSet | Literal[False] = patch_ng.fromstring(diff_bytes)  # pyright: ignore[reportUnknownMemberType]
+    return result if result is not False else None
+
+
+def _count_hunks(patch_set: patch_ng.PatchSet) -> int:
+    """Count total hunks across all items in a PatchSet.
+
+    This wrapper provides type hints for the untyped patch_ng library.
+    From source code inspection: PatchSet.items is list[Patch], Patch.hunks is list[Hunk].
+    Type ignore needed because patch_ng lacks type annotations.
+    """
+    items: list[patch_ng.Patch] = patch_set.items  # pyright: ignore[reportUnknownMemberType]
+    # Each Patch has a hunks attribute (list[Hunk])
+    return sum(len(item.hunks) for item in items)  # pyright: ignore[reportUnknownArgumentType, reportUnknownMemberType]
+
+
+def _apply_patch(patch_set: patch_ng.PatchSet, root: str) -> bool:
+    """Apply a patch to files under the given root directory.
+
+    This wrapper provides type hints for the untyped patch_ng.apply method.
+    """
+    success: Any = patch_set.apply(root=root)  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+    return bool(success)  # pyright: ignore[reportUnknownArgumentType]
+
+
 class Params(BaseModel):
     path: str = Field(description="The absolute path to the file to apply the patch to.")
     diff: str = Field(description="The diff content in unified format to apply.")
@@ -22,7 +52,7 @@ class PatchFile(CallableTool2[Params]):
     description: str = (Path(__file__).parent / "patch.md").read_text(encoding="utf-8")
     params: type[Params] = Params
 
-    def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval, **kwargs):
+    def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval, **kwargs: Any):
         super().__init__(**kwargs)
         self._work_dir = builtin_args.KIMI_WORK_DIR
         self._approval = approval
@@ -87,10 +117,10 @@ class PatchFile(CallableTool2[Params]):
                 original_content = await f.read()
 
             # Create patch object directly from string (no temporary file needed!)
-            patch_set = patch_ng.fromstring(params.diff.encode("utf-8"))
+            patch_set = _parse_patch(params.diff.encode("utf-8"))
 
-            # Handle case where patch_ng.fromstring returns False on parse errors
-            if not patch_set or patch_set is True:
+            # Handle case where parsing failed
+            if patch_set is None:
                 return ToolError(
                     message=(
                         "Failed to parse diff content: invalid patch format or no valid hunks found"
@@ -99,7 +129,7 @@ class PatchFile(CallableTool2[Params]):
                 )
 
             # Count total hunks across all items
-            total_hunks = sum(len(item.hunks) for item in patch_set.items)
+            total_hunks = _count_hunks(patch_set)
 
             if total_hunks == 0:
                 return ToolError(
@@ -108,7 +138,7 @@ class PatchFile(CallableTool2[Params]):
                 )
 
             # Apply the patch
-            success = patch_set.apply(root=str(p.parent))
+            success = _apply_patch(patch_set, str(p.parent))
 
             if not success:
                 return ToolError(

kimi_cli/tools/file/read.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import override
+from typing import Any, override
 
 import aiofiles
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
@@ -47,8 +47,9 @@ class ReadFile(CallableTool2[Params]):
     )
     params: type[Params] = Params
 
-    def __init__(self, builtin_args: BuiltinSystemPromptArgs, **kwargs):
+    def __init__(self, builtin_args: BuiltinSystemPromptArgs, **kwargs: Any) -> None:
         super().__init__(**kwargs)
+
         self._work_dir = builtin_args.KIMI_WORK_DIR
 
     @override
@@ -84,7 +85,7 @@ class ReadFile(CallableTool2[Params]):
 
             lines: list[str] = []
             n_bytes = 0
-            truncated_line_numbers = []
+            truncated_line_numbers: list[int] = []
             max_lines_reached = False
             max_bytes_reached = False
             async with aiofiles.open(p, encoding="utf-8", errors="replace") as f:
@@ -108,7 +109,7 @@ class ReadFile(CallableTool2[Params]):
                         break
 
             # Format output with line numbers like `cat -n`
-            lines_with_no = []
+            lines_with_no: list[str] = []
             for line_num, line in zip(
                 range(params.line_offset, params.line_offset + len(lines)), lines, strict=True
             ):

kimi_cli/tools/file/replace.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import override
+from typing import Any, override
 
 import aiofiles
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
@@ -32,7 +32,7 @@ class StrReplaceFile(CallableTool2[Params]):
     description: str = (Path(__file__).parent / "replace.md").read_text(encoding="utf-8")
     params: type[Params] = Params
 
-    def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval, **kwargs):
+    def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval, **kwargs: Any):
         super().__init__(**kwargs)
         self._work_dir = builtin_args.KIMI_WORK_DIR
         self._approval = approval

kimi_cli/tools/file/write.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Literal, override
+from typing import Any, Literal, override
 
 import aiofiles
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
@@ -29,7 +29,7 @@ class WriteFile(CallableTool2[Params]):
     description: str = (Path(__file__).parent / "write.md").read_text(encoding="utf-8")
     params: type[Params] = Params
 
-    def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval, **kwargs):
+    def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval, **kwargs: Any):
         super().__init__(**kwargs)
         self._work_dir = builtin_args.KIMI_WORK_DIR
         self._approval = approval

kimi_cli/tools/mcp.py

@@ -1,12 +1,15 @@
+from typing import Any
+
 import fastmcp
 import mcp
 from fastmcp.client.client import CallToolResult
+from fastmcp.client.transports import ClientTransport
 from kosong.base.message import AudioURLPart, ContentPart, ImageURLPart, TextPart
 from kosong.tooling import CallableTool, ToolOk, ToolReturnType
 
 
-class MCPTool(CallableTool):
-    def __init__(self, mcp_tool: mcp.Tool, client: fastmcp.Client, **kwargs):
+class MCPTool[T: ClientTransport](CallableTool):
+    def __init__(self, mcp_tool: mcp.Tool, client: fastmcp.Client[T], **kwargs: Any):
         super().__init__(
             name=mcp_tool.name,
             description=mcp_tool.description or "",
@@ -16,7 +19,7 @@ class MCPTool(CallableTool):
         self._mcp_tool = mcp_tool
         self._client = client
 
-    async def __call__(self, *args, **kwargs) -> ToolReturnType:
+    async def __call__(self, *args: Any, **kwargs: Any) -> ToolReturnType:
         async with self._client as client:
             result = await client.call_tool(self._mcp_tool.name, kwargs, timeout=20)
             return convert_tool_result(result)

kimi_cli/tools/task/__init__.py

@@ -1,6 +1,6 @@
 import asyncio
 from pathlib import Path
-from typing import override
+from typing import Any, override
 
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
@@ -49,7 +49,7 @@ class Task(CallableTool2[Params]):
     name: str = "Task"
     params: type[Params] = Params
 
-    def __init__(self, agent_spec: ResolvedAgentSpec, runtime: Runtime, **kwargs):
+    def __init__(self, agent_spec: ResolvedAgentSpec, runtime: Runtime, **kwargs: Any):
         super().__init__(
             description=load_desc(
                 Path(__file__).parent / "task.md",

kimi_cli/tools/web/search.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import override
+from typing import Any, override
 
 from kosong.tooling import CallableTool2, ToolReturnType
 from pydantic import BaseModel, Field, ValidationError
@@ -39,7 +39,7 @@ class SearchWeb(CallableTool2[Params]):
     description: str = load_desc(Path(__file__).parent / "search.md", {})
     params: type[Params] = Params
 
-    def __init__(self, config: Config, **kwargs):
+    def __init__(self, config: Config, **kwargs: Any):
         super().__init__(**kwargs)
         if config.services.moonshot_search is not None:
             self._base_url = config.services.moonshot_search.base_url

kimi_cli/ui/wire/README.md

@@ -0,0 +1,109 @@
+# Wire over STDIO
+
+Learn how `WireServer` (src/kimi_cli/ui/wire/__init__.py) exposes the Soul runtime over stdio.
+Use this reference when building clients or SDKs.
+
+## Transport
+- The server acquires stdio streams via `acp.stdio_streams()` and stays alive until stdin closes.
+- Messages use newline-delimited JSON. Each object must include `"jsonrpc": "2.0"`.
+- Outbound JSON is UTF-8 encoded with compact separators `(",", ":")`.
+
+## Lifecycle
+1. A client launches `kimi` (or another entry point) with the wire UI enabled.
+2. `WireServer.run()` spawns a reader loop on stdin and a writer loop draining an internal queue.
+3. Incoming payloads are validated by `JSONRPC_MESSAGE_ADAPTER`; invalid objects only log warnings.
+4. The Soul uses `Wire` (src/kimi_cli/wire/__init__.py); the UI forwards every message as JSON-RPC.
+5. EOF on stdin or a fatal error cancels the Soul, rejects approvals, and closes stdout.
+
+## Client → Server calls
+
+### `run`
+- Request:
+  ```json
+  {"jsonrpc": "2.0", "id": "<request-id>", "method": "run", "params": {"input": "<prompt>"}}
+  ```
+  `params.prompt` is accepted as an alias for `params.input`.
+- Success results:
+  - `{"status": "finished"}` when the run completes.
+  - `{"status": "cancelled"}` when either side interrupts.
+  - `{"status": "max_steps_reached", "steps": <int>}` when the step limit triggers.
+- Error codes:
+  - `-32000`: A run is already in progress.
+  - `-32602`: The `input` or `prompt` parameter is missing or not a string.
+  - `-32001`: LLM is not configured.
+  - `-32002`: The chat provider reported an error.
+  - `-32003`: The requested LLM is unsupported.
+  - `-32099`: An unhandled exception occurred during the run.
+
+### `interrupt`
+- Request:
+  ```json
+  {"jsonrpc": "2.0", "id": "<request-id>", "method": "interrupt", "params": {}}
+  ```
+  The `id` field is optional; omitting it turns the request into a notification.
+- Success results:
+  - `{"status": "ok"}` when a running Soul acknowledges the interrupt.
+  - `{"status": "idle"}` when no run is active.
+- Interrupt requests never raise protocol errors.
+
+## Server → Client traffic
+
+### Event notifications
+Events are JSON-RPC notifications with method `event` and no `id`.
+Payloads come from `serialize_event` (src/kimi_cli/wire/message.py):
+- `step_begin`: payload `{"n": <int>}` with the 1-based step counter.
+- `step_interrupted`: no payload; the Soul paused mid-step.
+- `compaction_begin`: no payload; a compaction pass started.
+- `compaction_end`: no payload; always follows `compaction_begin`.
+- `status_update`: payload `{"context_usage": <int>}` from `StatusSnapshot`.
+- `content_part`: JSON object produced by `ContentPart.model_dump(mode="json", exclude_none=True)`.
+- `tool_call`: JSON object produced by `ToolCall.model_dump(mode="json", exclude_none=True)`.
+- `tool_call_part`: JSON object from `ToolCallPart.model_dump(mode="json", exclude_none=True)`.
+- `tool_result`: object with `tool_call_id`, `ok`, and `result` (`output`, `message`, `brief`).
+  When `ok` is true the `output` may be text, a JSON object, or an array of JSON objects for
+  multi-part content.
+
+Event order mirrors Soul execution because the server uses an `asyncio.Queue` for FIFO delivery.
+
+### Approval requests
+- Approval prompts use method `request`; their `id` equals the UUID in `ApprovalRequest.id`:
+  ```json
+  {
+    "jsonrpc": "2.0",
+    "id": "<approval-id>",
+    "method": "request",
+    "params": {
+      "type": "approval",
+      "payload": {
+        "id": "<approval-id>",
+        "tool_call_id": "<tool-call-id>",
+        "sender": "<agent>",
+        "action": "<action>",
+        "description": "<human readable context>"
+      }
+    }
+  }
+  ```
+- Clients reply with JSON-RPC success.
+  `result.response` must be `approve`, `approve_for_session`, or `reject`:
+  ```json
+  {"jsonrpc": "2.0", "id": "<approval-id>", "result": {"response": "approve"}}
+  ```
+- Error responses or unknown values are interpreted as rejection.
+- Unanswered approvals are auto-rejected during server shutdown.
+
+## Error responses from the server
+Errors follow JSON-RPC semantics.
+The error object includes `code` and `message`.
+Custom codes live in the `-320xx` range.
+Clients should allow an optional `data` field even though the server omits it today.
+
+## Shutdown semantics
+- Shutdown cancels runs, stops the writer queue, rejects pending approvals, and closes stdout.
+- EOF on stdout signals process exit; clients can treat it as terminal.
+
+## Implementation notes for SDK authors
+- Only one `run` call may execute at a time; queue additional runs client side.
+- The payloads for `content_part`, `tool_call`, and `tool_call_part` already contain JSON objects.
+- Approval handling is synchronous; always send a response even if the user cancels.
+- Logging is verbose for non-stream messages; unknown methods are ignored for forward compatibility.

kimi_cli/ui/wire/__init__.py

@@ -0,0 +1,340 @@
+import asyncio
+import contextlib
+import json
+from collections.abc import Awaitable, Callable
+from typing import Any, Literal
+
+import acp  # pyright: ignore[reportMissingTypeStubs]
+from kosong.chat_provider import ChatProviderError
+from pydantic import ValidationError
+
+from kimi_cli.soul import LLMNotSet, LLMNotSupported, MaxStepsReached, RunCancelled, Soul, run_soul
+from kimi_cli.utils.logging import logger
+from kimi_cli.wire import WireUISide
+from kimi_cli.wire.message import (
+    ApprovalRequest,
+    ApprovalResponse,
+    Event,
+    serialize_approval_request,
+    serialize_event,
+)
+
+from .jsonrpc import (
+    JSONRPC_MESSAGE_ADAPTER,
+    JSONRPC_VERSION,
+    JSONRPCErrorResponse,
+    JSONRPCRequest,
+    JSONRPCSuccessResponse,
+)
+
+_ResultKind = Literal["ok", "error"]
+
+
+class _SoulRunner:
+    def __init__(
+        self,
+        soul: Soul,
+        send_event: Callable[[Event], Awaitable[None]],
+        request_approval: Callable[[ApprovalRequest], Awaitable[ApprovalResponse]],
+    ):
+        self._soul = soul
+        self._send_event = send_event
+        self._request_approval = request_approval
+        self._cancel_event: asyncio.Event | None = None
+        self._task: asyncio.Task[tuple[_ResultKind, Any]] | None = None
+
+    @property
+    def is_running(self) -> bool:
+        return self._task is not None and not self._task.done()
+
+    async def run(self, user_input: str) -> tuple[_ResultKind, Any]:
+        if self.is_running:
+            raise RuntimeError("Soul is already running")
+
+        self._cancel_event = asyncio.Event()
+        self._task = asyncio.create_task(self._run(user_input))
+        try:
+            return await self._task
+        finally:
+            self._task = None
+            self._cancel_event = None
+
+    async def interrupt(self) -> None:
+        if self._cancel_event is not None:
+            self._cancel_event.set()
+
+    async def shutdown(self) -> None:
+        await self.interrupt()
+        if self._task is not None:
+            self._task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._task
+            self._task = None
+            self._cancel_event = None
+
+    async def _run(self, user_input: str) -> tuple[_ResultKind, Any]:
+        assert self._cancel_event is not None
+        try:
+            await run_soul(
+                self._soul,
+                user_input,
+                self._ui_loop,
+                self._cancel_event,
+            )
+        except LLMNotSet:
+            return ("error", (-32001, "LLM is not configured"))
+        except LLMNotSupported as e:
+            return ("error", (-32003, f"LLM not supported: {e}"))
+        except ChatProviderError as e:
+            return ("error", (-32002, f"LLM provider error: {e}"))
+        except MaxStepsReached as e:
+            return ("ok", {"status": "max_steps_reached", "steps": e.n_steps})
+        except RunCancelled:
+            return ("ok", {"status": "cancelled"})
+        except asyncio.CancelledError:
+            raise
+        except Exception as e:
+            logger.exception("Soul run failed:")
+            return ("error", (-32099, f"Run failed: {e}"))
+        return ("ok", {"status": "finished"})
+
+    async def _ui_loop(self, wire: WireUISide) -> None:
+        while True:
+            message = await wire.receive()
+            if isinstance(message, ApprovalRequest):
+                response = await self._request_approval(message)
+                message.resolve(response)
+            else:
+                # must be Event
+                await self._send_event(message)
+
+
+class WireServer:
+    def __init__(self, soul: Soul):
+        self._reader: asyncio.StreamReader | None = None
+        self._writer: asyncio.StreamWriter | None = None
+        self._write_task: asyncio.Task[None] | None = None
+        self._send_queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue()
+        self._pending_requests: dict[str, ApprovalRequest] = {}
+        self._runner = _SoulRunner(
+            soul,
+            send_event=self._send_event,
+            request_approval=self._request_approval,
+        )
+
+    async def run(self) -> bool:
+        logger.info("Starting Wire server on stdio")
+
+        self._reader, self._writer = await acp.stdio_streams()
+        self._write_task = asyncio.create_task(self._write_loop())
+        try:
+            await self._read_loop()
+        finally:
+            await self._shutdown()
+
+        return True
+
+    async def _read_loop(self) -> None:
+        assert self._reader is not None
+
+        while True:
+            line = await self._reader.readline()
+            if not line:
+                logger.info("stdin closed, Wire server exiting")
+                break
+
+            try:
+                payload = json.loads(line.decode("utf-8"))
+            except json.JSONDecodeError:
+                logger.warning("Invalid JSON line: {line}", line=line)
+                continue
+
+            await self._dispatch(payload)
+
+    async def _dispatch(self, payload: dict[str, Any]) -> None:
+        version = payload.get("jsonrpc")
+        if version != JSONRPC_VERSION:
+            logger.warning("Unexpected jsonrpc version: {version}", version=version)
+            return
+
+        try:
+            message = JSONRPC_MESSAGE_ADAPTER.validate_python(payload)
+        except ValidationError as e:
+            logger.warning(
+                "Ignoring malformed JSON-RPC payload: {message}; error={error}",
+                message=payload,
+                error=str(e),
+            )
+            return
+
+        match message:
+            case JSONRPCRequest():
+                await self._handle_request(message)
+            case JSONRPCSuccessResponse() | JSONRPCErrorResponse():
+                await self._handle_response(message)
+
+    async def _handle_request(self, message: JSONRPCRequest) -> None:
+        method = message.method
+        msg_id = message.id
+        params = message.params
+
+        if method == "run":
+            await self._handle_run(msg_id, params)
+        elif method == "interrupt":
+            await self._handle_interrupt(msg_id)
+        else:
+            logger.warning("Unknown method: {method}", method=method)
+            if msg_id is not None:
+                await self._send_error(msg_id, -32601, f"Unknown method: {method}")
+
+    async def _handle_response(
+        self,
+        message: JSONRPCSuccessResponse | JSONRPCErrorResponse,
+    ) -> None:
+        msg_id = message.id
+        if msg_id is None:
+            logger.warning("Response without id: {message}", message=message.model_dump())
+            return
+
+        pending = self._pending_requests.get(msg_id)
+        if pending is None:
+            logger.warning("No pending request for response id={id}", id=msg_id)
+            return
+
+        try:
+            if isinstance(message, JSONRPCErrorResponse):
+                pending.resolve(ApprovalResponse.REJECT)
+            else:
+                response = self._parse_approval_response(message.result)
+                pending.resolve(response)
+        finally:
+            self._pending_requests.pop(msg_id, None)
+
+    async def _handle_run(self, msg_id: Any, params: dict[str, Any]) -> None:
+        if msg_id is None:
+            logger.warning("Run notification ignored")
+            return
+
+        if self._runner.is_running:
+            await self._send_error(msg_id, -32000, "Run already in progress")
+            return
+
+        user_input = params.get("input")
+        if not isinstance(user_input, str):
+            user_input = params.get("prompt")
+        if not isinstance(user_input, str):
+            await self._send_error(msg_id, -32602, "`input` (or `prompt`) must be a string")
+            return
+
+        try:
+            kind, payload = await self._runner.run(user_input)
+        except RuntimeError:
+            await self._send_error(msg_id, -32000, "Run already in progress")
+            return
+
+        if kind == "error":
+            code, message = payload
+            await self._send_error(msg_id, code, message)
+        else:
+            await self._send_response(msg_id, payload)
+
+    async def _handle_interrupt(self, msg_id: Any) -> None:
+        if not self._runner.is_running:
+            if msg_id is not None:
+                await self._send_response(msg_id, {"status": "idle"})
+            return
+
+        await self._runner.interrupt()
+        if msg_id is not None:
+            await self._send_response(msg_id, {"status": "ok"})
+
+    async def _send_event(self, event: Event) -> None:
+        await self._send_notification("event", serialize_event(event))
+
+    async def _request_approval(self, request: ApprovalRequest) -> ApprovalResponse:
+        self._pending_requests[request.id] = request
+
+        await self._send_request(
+            request.id,
+            "request",
+            {"type": "approval", "payload": serialize_approval_request(request)},
+        )
+
+        try:
+            return await request.wait()
+        finally:
+            self._pending_requests.pop(request.id, None)
+
+    def _parse_approval_response(self, result: dict[str, Any]) -> ApprovalResponse:
+        value = result.get("response")
+        try:
+            if isinstance(value, ApprovalResponse):
+                return value
+            return ApprovalResponse(str(value))
+        except ValueError:
+            logger.warning("Unknown approval response: {value}", value=value)
+            return ApprovalResponse.REJECT
+
+    async def _write_loop(self) -> None:
+        assert self._writer is not None
+
+        try:
+            while True:
+                try:
+                    payload = await self._send_queue.get()
+                except asyncio.QueueShutDown:
+                    logger.debug("Send queue shut down, stopping Wire server write loop")
+                    break
+                data = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
+                self._writer.write(data.encode("utf-8") + b"\n")
+                await self._writer.drain()
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.exception("Wire server write loop error:")
+            raise
+
+    async def _send_notification(self, method: str, params: Any) -> None:
+        await self._enqueue_payload(
+            {"jsonrpc": JSONRPC_VERSION, "method": method, "params": params}
+        )
+
+    async def _send_request(self, msg_id: Any, method: str, params: Any) -> None:
+        await self._enqueue_payload(
+            {"jsonrpc": JSONRPC_VERSION, "id": msg_id, "method": method, "params": params}
+        )
+
+    async def _send_response(self, msg_id: Any, result: Any) -> None:
+        await self._enqueue_payload({"jsonrpc": JSONRPC_VERSION, "id": msg_id, "result": result})
+
+    async def _send_error(self, msg_id: Any, code: int, message: str) -> None:
+        await self._enqueue_payload(
+            {"jsonrpc": JSONRPC_VERSION, "id": msg_id, "error": {"code": code, "message": message}}
+        )
+
+    async def _enqueue_payload(self, payload: dict[str, Any]) -> None:
+        try:
+            await self._send_queue.put(payload)
+        except asyncio.QueueShutDown:
+            logger.debug("Send queue shut down; dropping payload: {payload}", payload=payload)
+
+    async def _shutdown(self) -> None:
+        await self._runner.shutdown()
+        self._send_queue.shutdown()
+
+        if self._write_task is not None:
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._write_task
+
+        for request in self._pending_requests.values():
+            if not request.resolved:
+                request.resolve(ApprovalResponse.REJECT)
+        self._pending_requests.clear()
+
+        if self._writer is not None:
+            self._writer.close()
+            with contextlib.suppress(Exception):
+                await self._writer.wait_closed()
+            self._writer = None
+
+        self._reader = None

kimi_cli/ui/wire/jsonrpc.py

@@ -0,0 +1,48 @@
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, TypeAdapter
+
+JSONRPC_VERSION = "2.0"
+
+
+class _MessageBase(BaseModel):
+    jsonrpc: Literal["2.0"]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class JSONRPCRequest(_MessageBase):
+    method: str
+    id: str | None = None
+    params: dict[str, Any] = Field(default_factory=dict)
+
+
+class _ResponseBase(_MessageBase):
+    id: str | None
+
+
+class JSONRPCSuccessResponse(_ResponseBase):
+    result: dict[str, Any]
+
+
+class JSONRPCErrorObject(BaseModel):
+    code: int
+    message: str
+    data: Any | None = None
+
+
+class JSONRPCErrorResponse(_ResponseBase):
+    error: JSONRPCErrorObject
+
+
+JSONRPCMessage = JSONRPCRequest | JSONRPCSuccessResponse | JSONRPCErrorResponse
+JSONRPC_MESSAGE_ADAPTER = TypeAdapter[JSONRPCMessage](JSONRPCMessage)
+
+__all__ = [
+    "JSONRPCRequest",
+    "JSONRPCSuccessResponse",
+    "JSONRPCErrorObject",
+    "JSONRPCErrorResponse",
+    "JSONRPCMessage",
+    "JSONRPC_MESSAGE_ADAPTER",
+]

kimi_cli/wire/message.py

@@ -1,10 +1,11 @@
 import asyncio
 import uuid
+from collections.abc import Sequence
 from enum import Enum
-from typing import TYPE_CHECKING, NamedTuple
+from typing import TYPE_CHECKING, Any, NamedTuple
 
 from kosong.base.message import ContentPart, ToolCall, ToolCallPart
-from kosong.tooling import ToolResult
+from kosong.tooling import ToolOk, ToolResult
 
 if TYPE_CHECKING:
     from kimi_cli.soul import StatusSnapshot
@@ -89,3 +90,89 @@ class ApprovalRequest:
 
 
 type WireMessage = Event | ApprovalRequest
+
+
+def serialize_event(event: Event) -> dict[str, Any]:
+    """
+    Convert an event message into a JSON-serializable dictionary.
+    """
+    match event:
+        case StepBegin():
+            return {"type": "step_begin", "payload": {"n": event.n}}
+        case StepInterrupted():
+            return {"type": "step_interrupted"}
+        case CompactionBegin():
+            return {"type": "compaction_begin"}
+        case CompactionEnd():
+            return {"type": "compaction_end"}
+        case StatusUpdate():
+            return {
+                "type": "status_update",
+                "payload": {"context_usage": event.status.context_usage},
+            }
+        case ContentPart():
+            return {
+                "type": "content_part",
+                "payload": event.model_dump(mode="json", exclude_none=True),
+            }
+        case ToolCall():
+            return {
+                "type": "tool_call",
+                "payload": event.model_dump(mode="json", exclude_none=True),
+            }
+        case ToolCallPart():
+            return {
+                "type": "tool_call_part",
+                "payload": event.model_dump(mode="json", exclude_none=True),
+            }
+        case ToolResult():
+            return {
+                "type": "tool_result",
+                "payload": serialize_tool_result(event),
+            }
+
+
+def serialize_approval_request(request: ApprovalRequest) -> dict[str, Any]:
+    """
+    Convert an ApprovalRequest into a JSON-serializable dictionary.
+    """
+    return {
+        "id": request.id,
+        "tool_call_id": request.tool_call_id,
+        "sender": request.sender,
+        "action": request.action,
+        "description": request.description,
+    }
+
+
+def serialize_tool_result(result: ToolResult) -> dict[str, Any]:
+    if isinstance(result.result, ToolOk):
+        ok = True
+        result_data = {
+            "output": _serialize_tool_output(result.result.output),
+            "message": result.result.message,
+            "brief": result.result.brief,
+        }
+    else:
+        ok = False
+        result_data = {
+            "output": result.result.output,
+            "message": result.result.message,
+            "brief": result.result.brief,
+        }
+    return {
+        "tool_call_id": result.tool_call_id,
+        "ok": ok,
+        "result": result_data,
+    }
+
+
+def _serialize_tool_output(
+    output: str | ContentPart | Sequence[ContentPart],
+) -> str | list[Any] | dict[str, Any]:
+    if isinstance(output, str):
+        return output
+    elif isinstance(output, ContentPart):
+        return output.model_dump(mode="json", exclude_none=True)
+    else:  # Sequence[ContentPart]
+        return [part.model_dump(mode="json", exclude_none=True) for part in output]

{kimi_cli-0.45.dist-info → kimi_cli-0.46.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.3
 Name: kimi-cli
-Version: 0.45
+Version: 0.46
 Summary: Kimi CLI is your next CLI agent.
 Requires-Dist: agent-client-protocol==0.6.2
 Requires-Dist: aiofiles==25.1.0
 Requires-Dist: aiohttp==3.13.2
 Requires-Dist: click==8.3.0
-Requires-Dist: kosong==0.16.2
+Requires-Dist: kosong==0.17.0
 Requires-Dist: loguru==0.7.3
 Requires-Dist: patch-ng==1.19.0
 Requires-Dist: prompt-toolkit==3.0.52
@@ -29,6 +29,7 @@ Description-Content-Type: text/markdown
 [![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)
 
 [中文](https://www.kimi.com/coding/docs/kimi-cli.html)
 

{kimi_cli-0.45.dist-info → kimi_cli-0.46.dist-info}/RECORD

@@ -1,15 +1,15 @@
-kimi_cli/CHANGELOG.md,sha256=0affdbd19f99b6dedb4cc2cac63eb2f9f942d8cfab44f01b445374764b572a10,8603
+kimi_cli/CHANGELOG.md,sha256=cd7f214ad9fb6cdc9af293cc90d69aeba9c24b4dc878486a99187de70ff197d2,8832
 kimi_cli/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
 kimi_cli/agents/default/agent.yaml,sha256=6e5c51987ef5cfc0c4c4e34cc20b6fc975953ee219623fccae81a19155aab7b3,709
 kimi_cli/agents/default/sub.yaml,sha256=e0c1ea34fdb04b0d6dc635709f0f130aff25d7f9fb97e238470143c8145be251,634
 kimi_cli/agents/default/system.md,sha256=1d8fd4956b2442215396b5e9651771c9da8f9505ccbd3b6d5e91b1ac4ff35418,5001
 kimi_cli/agentspec.py,sha256=1148b5184ca610b2fb261ce365a63eb2fc9d09497330fe0ea4b2567fc98d5657,4307
-kimi_cli/app.py,sha256=34fde6911d3b4fa6ada013f5ae714cdf354be479da9adb26c6460de0a9ba10c3,7053
-kimi_cli/cli.py,sha256=5731276d9c13e58962c39cdf9db3a57bd875a7a09d560c64498454df62b717a0,6910
-kimi_cli/config.py,sha256=5524c2dd7d3d10e7965901253c754185a4e4b1d30937598ff2b321a070c760be,5012
+kimi_cli/app.py,sha256=f7a6a39300df101504882121d3930d6a8660e0f4182421aac456fe3fa684e560,7260
+kimi_cli/cli.py,sha256=54bd72907fc99feea96bbaf9eeb808a2a21a2f0c0c6b5d11229a4263597a5920,7215
+kimi_cli/config.py,sha256=85ce4877f0f05f72e2f390b6ebb6e8be5525a719ea4a6e3560817527c5261fb8,5025
 kimi_cli/constant.py,sha256=78e25b9304cca7b6f70bb08bf0e1fee4b066297a05386e56dd6935ba42027cd9,110
 kimi_cli/exception.py,sha256=a3fec07566da7d2d34be8cc454fb825f34109bbde3cddf69e1ece6ab21b4b219,259
-kimi_cli/llm.py,sha256=fdb4f944d6ccec9fe5b8bc1f80bb283df629663659fcdbffe405af2f61f73733,4442
+kimi_cli/llm.py,sha256=a1c3537a427c0c3ace75bbc0cebf3749215562750570113078a1fcc9e9c80a86,5026
 kimi_cli/metadata.py,sha256=9e9d4bc12ff26fc34e0e09d9068be989f2ff3c8b682ef453de69e442f8f672a1,1557
 kimi_cli/prompts/__init__.py,sha256=6dc5ed2d841f145c09550075f30853cdc51f00d2f5d9aa1097f8edea770536e7,174
 kimi_cli/prompts/compact.md,sha256=6655bd7d8270b24d8f97b51ef7c471cf71d686c56f8ec9a5cc9e47caa3aae87c,1877
@@ -26,27 +26,27 @@ kimi_cli/soul/denwarenji.py,sha256=66b95f052a1fa844e2347972d34e1916a7be24d3e4937
 kimi_cli/soul/kimisoul.py,sha256=68c65fe0f97700832a42018ae00892d38dc79f14759265042f47b707dbc0c749,11822
 kimi_cli/soul/message.py,sha256=7a52a6d4d63ef1a3621d93d5ff86887baa7e67019bf2e9a08c374fc130b8d152,2541
 kimi_cli/soul/runtime.py,sha256=9421a3ce6882587a95ecdf77b3d75f3b7ecab55cf68dc57e3e563b93e5a02e46,2690
-kimi_cli/soul/toolset.py,sha256=60166d89ef0efac690fa6866e88afe70fbe80ad862ba2524d70ddf657a730d14,744
-kimi_cli/tools/__init__.py,sha256=4d612402814eede7182e0a55e7dd21c4532b5dd44700dc744763a8308c2f74f8,3280
-kimi_cli/tools/bash/__init__.py,sha256=de21b19c714bda53f6c89e3348c4c82fb4278040130fed1d261b3ab203054e8c,3028
+kimi_cli/soul/toolset.py,sha256=34d3cb269cb28f2ca1a2323d984625e2ee822d124789a5fcf63651bddf2102fe,777
+kimi_cli/tools/__init__.py,sha256=3b0c7446947219933d0b6819c45b8b57befb8e498171b3374720925697b8c11e,3430
+kimi_cli/tools/bash/__init__.py,sha256=e7821ce9296171c538117398d77311d220a8000de625302f9b8faf62de5910a5,3304
 kimi_cli/tools/bash/bash.md,sha256=5d9cc54b3718097951340b0a737c8e1fa308341fd2c4ebd121be94de31dd5f73,2348
-kimi_cli/tools/dmail/__init__.py,sha256=a9186ed4e52c34cab7516060bb6edca73324912233b1581c0d3a40b026400133,1277
+kimi_cli/tools/dmail/__init__.py,sha256=dfc9ceccb5a47211ab99b7afa4624d13bf147ef68e2a079867f93cf46dfb58d2,1302
 kimi_cli/tools/dmail/dmail.md,sha256=0d18cae387dd52127ddc99e296253c09e68ccba5f343153c0adbe77d7586e759,1912
 kimi_cli/tools/file/__init__.py,sha256=1516fb4c71097f9c14b605e7b9a1872af8786bdcb48323d1fa83bb1419436abb,546
 kimi_cli/tools/file/glob.md,sha256=11fbfaf6033f57b69c6f91077ddd90505036937cd7217600d96992b9a48b7ca7,1400
-kimi_cli/tools/file/glob.py,sha256=67b0b55e95b57e34cb43ecf382667d1b9b78903787c00bb2d0929dbede812f2f,5413
+kimi_cli/tools/file/glob.py,sha256=a95f0f502fe6458f8c21a7aa5f15e27828993b05fed83b83f8a7c0dc9c50a48b,5431
 kimi_cli/tools/file/grep.md,sha256=12353db42cf3b5d9d91ac7c0f0b9c2a732e8b050c23a78f4e668db823cca4d50,245
-kimi_cli/tools/file/grep.py,sha256=01794320049b46207aeb28bd7f3dbea373ede891916107cab871ea959e81a335,9787
+kimi_cli/tools/file/grep.py,sha256=77c8ae701c2d827bc5784e140fb007c4153162b278803956915858064f8733e5,9830
 kimi_cli/tools/file/patch.md,sha256=f9edbed6c6a03bf7448a51acc1f42622395fd7f1674a814e9a3b2302d3b7b92e,404
-kimi_cli/tools/file/patch.py,sha256=7e31d85ece4ece2439e9dfd085505e496d9e47d176b820c61798e3c4f71628db,5228
+kimi_cli/tools/file/patch.py,sha256=6ee74656c611510605cc2a70e32b8ed291163e79c458b06fd5a310d48650359f,6632
 kimi_cli/tools/file/read.md,sha256=4c2d83e557daadc0612fb1a613e252b2c8e4df7ae57e6db094e9e75e994cb23b,1066
-kimi_cli/tools/file/read.py,sha256=1d3d8116ee23f224d04c5ba10e3c3261e94fbbe3b932d57ae5fca48a0afdb592,5068
+kimi_cli/tools/file/read.py,sha256=76ea260a813a987a4e34706f6cc3c2b77fc3f31a76831883caa91f9ab86df6a6,5109
 kimi_cli/tools/file/replace.md,sha256=f429f263fa580f2f6107907a33ba8800dcdbd4fc1d9ff8dc4f858bd76ec6bbc6,267
-kimi_cli/tools/file/replace.py,sha256=8df993fb49a975b87820fbdbc7d7b349e18516250b0f895dd047b87c3df89e73,5204
+kimi_cli/tools/file/replace.py,sha256=c6c83869bc1431c645de52c920713e38970668fc531ee005680317a0dfeb4095,5214
 kimi_cli/tools/file/write.md,sha256=f37b0f4742da57797ec4dd29fbd4fdc9b6617c6be644724a3b16d651c6129cec,324
-kimi_cli/tools/file/write.py,sha256=22f4eb8e635b279e48bde7f09e7416a01b8ed88c140424c149a6398a0a321f1a,4378
-kimi_cli/tools/mcp.py,sha256=12f63c9ee5b82a5b0f23daca0b5ce4ceb3a6190ce5b553ee24e499699521e426,3620
-kimi_cli/tools/task/__init__.py,sha256=193ad32d83e6da7991416b845be5a31cc64657c0945872acfc087058dd1d7b37,6566
+kimi_cli/tools/file/write.py,sha256=a7b48ae20ba6e8e6577ce30bc8561c74d0e76d4cebaa107bdcafb7611eae9dfc,4388
+kimi_cli/tools/mcp.py,sha256=4e8b71c316a5d752ad05ee14af3a3db8ba433b7cc0a2231de4e1a03d4cf9365c,3736
+kimi_cli/tools/task/__init__.py,sha256=7bd6bf96a40d0e2456079f56e2854f71263ad8844265be628753b5eec4a34d5c,6576
 kimi_cli/tools/task/task.md,sha256=391cc3553c7d310a323626bae180dd41cb810fb1233583713ebde105f954147a,2280
 kimi_cli/tools/test.py,sha256=c094a91a2d1a5259e192f1147facd5eebd5e5c413787fce167db90e4b41b5119,1442
 kimi_cli/tools/think/__init__.py,sha256=31b06088e2404cb09d42e0acec97c185e4861890bb687f28b41f39cea01b5733,603
@@ -58,7 +58,7 @@ kimi_cli/tools/web/__init__.py,sha256=e13108c598828a8a05907a7a821e7ac92f5d63572b
 kimi_cli/tools/web/fetch.md,sha256=56d00bd93b4e379c4f7efe445fce963eb26b8d20f85d4c19097ba6f33bd0019a,67
 kimi_cli/tools/web/fetch.py,sha256=66448121d27d67f75b977c32244c721c2ccff1b2e097c2fe6717e66018d8f747,3183
 kimi_cli/tools/web/search.md,sha256=24049f9e90d37083e0fc78b8b2e3a5f6fadf09bea00f36712b235d1212a2f532,146
-kimi_cli/tools/web/search.py,sha256=85de343b20bc9e58de8a09aba7c3aac619d6fc6d30a6a5b565108faeb4500faf,4517
+kimi_cli/tools/web/search.py,sha256=5a5a3b7b160d6bd41f99419f7b7ae346f9dd29d37b8dbbe2dad912763d462554,4527
 kimi_cli/ui/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
 kimi_cli/ui/acp/__init__.py,sha256=a35e17273e943168882865f90d922180c5a1f01de0d128c899ffcfe55a9db3c3,17120
 kimi_cli/ui/print/__init__.py,sha256=ca402bec701a253acd6de5b57d59635ac0b05d4013cebc26877c5aa4aa2c27c7,5546
@@ -73,6 +73,9 @@ kimi_cli/ui/shell/replay.py,sha256=e54f58acebc46ad944e1a2cdf54d81559262d2cf8baf5
 kimi_cli/ui/shell/setup.py,sha256=8fbf2935fc5b972d2c3946e8dc9f4a7e9d2953810b57c0fb6f22172abf3e6fb5,5369
 kimi_cli/ui/shell/update.py,sha256=56dcb0bd1da82b98c22bfdddca717a2805bd8ac3e93bf23fb3b508549c41fae8,7340
 kimi_cli/ui/shell/visualize.py,sha256=1ca7a1e766f96f108318640d48552111d42b433e4ddb551af869d331c074d950,4112
+kimi_cli/ui/wire/README.md,sha256=0d9beaf38d4f4f1777013e85445e615fcacfe3a169d11151c42a141dec6196bd,4849
+kimi_cli/ui/wire/__init__.py,sha256=9252f53cd32b5a114afdbc402817a627818a48897554977908b5c5e64864801e,11932
+kimi_cli/ui/wire/jsonrpc.py,sha256=c093a540e70026cb48eae494cf4c8ad04f1180338eaaad0a23d64798bb679944,995
 kimi_cli/utils/aiohttp.py,sha256=f8f61e3beaf6439e949c33c3a10db3035bf88136e882b09c858ea92a4c888e00,245
 kimi_cli/utils/changelog.py,sha256=bfcf5a5a360b13648bb7a6abc83e427270caa502646b5acc950d62148510641c,3402
 kimi_cli/utils/logging.py,sha256=129298ac214ecd8d913c3431cc05d754f9c4c8c4042c458618bf9e8ddebdb763,399
@@ -82,8 +85,8 @@ kimi_cli/utils/pyinstaller.py,sha256=e5d709d0490ef8645bbed2d2363920c59f25bd17c04
 kimi_cli/utils/signals.py,sha256=20e0d158a1043189d44815fe3624cd0bfe41e99620a18ac9e12c0eda6db5220f,1387
 kimi_cli/utils/string.py,sha256=0d437d3633199df1051813af8b49a2f808c6525547310cc5c3d427710d2eae06,593
 kimi_cli/wire/__init__.py,sha256=9f1d7eb58f76885edaf76f769371c363ec801b46cada03883eeb3536fa2677f7,1896
-kimi_cli/wire/message.py,sha256=72222d3f3d7228a323dbba7b1084f35018104c58e4bb2aa51d0827984791841d,2398
-kimi_cli-0.45.dist-info/WHEEL,sha256=70ab3c2925fe316809860cb034f99ba13c4b49819b339959274aab755cc084a8,78
-kimi_cli-0.45.dist-info/entry_points.txt,sha256=97e051756296e9db3167f6dce61d6c88e58d170314a2d63d18c84c73a5c1333b,44
-kimi_cli-0.45.dist-info/METADATA,sha256=bac942d1519d1a5f2650199cb6add467e99274392d3e9b839707915a1acd58d0,5217
-kimi_cli-0.45.dist-info/RECORD,,
+kimi_cli/wire/message.py,sha256=005213250d05c3c724a5eac6f3c1c3843117439c5e5a24619e9570f59986f67e,5201
+kimi_cli-0.46.dist-info/WHEEL,sha256=70ab3c2925fe316809860cb034f99ba13c4b49819b339959274aab755cc084a8,78
+kimi_cli-0.46.dist-info/entry_points.txt,sha256=97e051756296e9db3167f6dce61d6c88e58d170314a2d63d18c84c73a5c1333b,44
+kimi_cli-0.46.dist-info/METADATA,sha256=0c527326fc9fdbbb9bfd7cabeba9cd0004add9a00082ae8594e350ab90904549,5309
+kimi_cli-0.46.dist-info/RECORD,,