kimi-cli 1.44.0__tar.gz → 1.46.0__tar.gz

{kimi_cli-1.44.0 → kimi_cli-1.46.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: kimi-cli
-Version: 1.44.0
+Version: 1.46.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
@@ -44,6 +44,9 @@ Description-Content-Type: text/markdown
 
 [Kimi Code](https://www.kimi.com/code/) | [Documentation](https://moonshotai.github.io/kimi-cli/en/) | [文档](https://moonshotai.github.io/kimi-cli/zh/)
 
+> [!IMPORTANT]
+> **Kimi Code CLI is evolving into [Kimi Code](https://github.com/MoonshotAI/kimi-code)** — the next-generation terminal AI agent from the same team. Installing Kimi Code automatically migrates your configuration and sessions. This project will be gradually wound down; the docs and existing installations remain available.
+
 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

{kimi_cli-1.44.0 → kimi_cli-1.46.0}/README.md

@@ -8,6 +8,9 @@
 
 [Kimi Code](https://www.kimi.com/code/) | [Documentation](https://moonshotai.github.io/kimi-cli/en/) | [文档](https://moonshotai.github.io/kimi-cli/zh/)
 
+> [!IMPORTANT]
+> **Kimi Code CLI is evolving into [Kimi Code](https://github.com/MoonshotAI/kimi-code)** — the next-generation terminal AI agent from the same team. Installing Kimi Code automatically migrates your configuration and sessions. This project will be gradually wound down; the docs and existing installations remain available.
+
 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

{kimi_cli-1.44.0 → kimi_cli-1.46.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kimi-cli"
-version = "1.44.0"
+version = "1.46.0"
 description = "Kimi Code CLI is your next CLI agent."
 readme = "README.md"
 requires-python = ">=3.12"

{kimi_cli-1.44.0 → kimi_cli-1.46.0}/src/kimi_cli/CHANGELOG.md

@@ -11,6 +11,18 @@ Only write entries that are worth mentioning to users.
 
 ## Unreleased
 
+## 1.46.0 (2026-05-28)
+
+- Shell: Support styled text in welcome tips
+- ACP: Replay session history on load
+- Core: Prevent TTY hang on exit
+- Core: Close MCP connections during shutdown
+
+## 1.45.0 (2026-05-26)
+
+- Shell: `/clear` is now an alias for `/new` — both commands start a new session; previously `/clear` only cleared context without creating a new session
+- Shell: Fix misleading "Quota exceeded" prefix shown on every 403 error
+
 ## 1.44.0 (2026-05-13)
 
 - Shell: Add slash command alias resolution — aliases such as `/h`, `?`, and `status` now resolve to their canonical commands (`/help`, `/usage`); the completer and help output display alias matches as `/name (alias)` for clarity

kimi_cli-1.46.0/src/kimi_cli/_build_info.py

@@ -0,0 +1 @@
+BUILD_SHA = "github.com/MoonshotAI/kimi-cli@fa527f657152"

{kimi_cli-1.44.0 → kimi_cli-1.46.0}/src/kimi_cli/acp/server.py

@@ -265,8 +265,8 @@ class ACPServer:
         # Check authentication before loading session
         self._check_auth()
 
-        await self._setup_session(cwd, session_id, mcp_servers)
-        # TODO: replay session history?
+        acp_session, _ = await self._setup_session(cwd, session_id, mcp_servers)
+        await acp_session.replay_history(acp_session.cli.soul.runtime.session.wire_file)
 
     async def resume_session(
         self, cwd: str, session_id: str, mcp_servers: list[MCPServer] | None = None, **kwargs: Any

{kimi_cli-1.44.0 → kimi_cli-1.46.0}/src/kimi_cli/acp/session.py

@@ -19,6 +19,7 @@ from kimi_cli.app import KimiCLI
 from kimi_cli.soul import LLMNotSet, LLMNotSupported, MaxStepsReached, RunCancelled
 from kimi_cli.tools import extract_key_argument
 from kimi_cli.utils.logging import logger
+from kimi_cli.wire.file import WireFile
 from kimi_cli.wire.types import (
     ApprovalRequest,
     ApprovalResponse,
@@ -246,6 +247,63 @@ class ACPSession:
             _current_turn_id.reset(token)
         return acp.PromptResponse(stop_reason="end_turn")
 
+    async def replay_history(self, wire_file: WireFile) -> None:
+        """Replay persisted wire history to an ACP client during session/load."""
+        token = _current_turn_id.set(None)
+        terminal_tool_calls_token = _terminal_tool_call_ids.set(set())
+        try:
+            async for record in wire_file.iter_records():
+                wire_msg = record.to_wire_message()
+                match wire_msg:
+                    case TurnBegin(user_input=user_input) | SteerInput(user_input=user_input):
+                        self._turn_state = _TurnState()
+                        _current_turn_id.set(self._turn_state.id)
+                        await self._send_user_input(user_input)
+                    case TurnEnd() | StepInterrupted():
+                        self._turn_state = None
+                        _current_turn_id.set(None)
+                    case StepBegin():
+                        pass
+                    case CompactionBegin() | CompactionEnd():
+                        pass
+                    case MCPLoadingBegin() | MCPLoadingEnd():
+                        pass
+                    case StatusUpdate():
+                        pass
+                    case Notification():
+                        await self._send_notification(wire_msg)
+                    case ThinkPart(think=think):
+                        await self._send_thinking(think)
+                    case TextPart(text=text):
+                        await self._send_text(text)
+                    case ContentPart():
+                        await self._send_text(f"[{wire_msg.__class__.__name__}]")
+                    case ToolCall():
+                        self._ensure_turn_state()
+                        await self._send_tool_call(wire_msg)
+                    case ToolCallPart():
+                        if self._turn_state is not None:
+                            await self._send_tool_call_part(wire_msg)
+                    case ToolResult():
+                        if self._turn_state is not None:
+                            await self._send_tool_result(wire_msg)
+                    case PlanDisplay():
+                        pass
+                    case ApprovalResponse() | SubagentEvent():
+                        pass
+                    case ApprovalRequest() | ToolCallRequest() | QuestionRequest():
+                        pass
+                    case _:
+                        pass
+        except Exception:
+            logger.exception(
+                "Failed to replay ACP session history from {file}:", file=wire_file.path
+            )
+        finally:
+            self._turn_state = None
+            _terminal_tool_call_ids.reset(terminal_tool_calls_token)
+            _current_turn_id.reset(token)
+
     async def cancel(self) -> None:
         if self._turn_state is None:
             logger.warning("Cancel requested but no prompt is running")
@@ -253,6 +311,32 @@ class ACPSession:
 
         self._turn_state.cancel_event.set()
 
+    def _ensure_turn_state(self) -> None:
+        if self._turn_state is None:
+            self._turn_state = _TurnState()
+            _current_turn_id.set(self._turn_state.id)
+
+    async def _send_user_input(self, user_input: str | list[ContentPart]) -> None:
+        if not self._id or not self._conn:
+            return
+
+        parts = [TextPart(text=user_input)] if isinstance(user_input, str) else user_input
+        for part in parts:
+            if isinstance(part, TextPart):
+                content: ACPContentBlock = acp.schema.TextContentBlock(type="text", text=part.text)
+            else:
+                logger.warning("Unsupported replay user input part: {part}", part=part)
+                content = acp.schema.TextContentBlock(
+                    type="text", text=f"[{part.__class__.__name__}]"
+                )
+            await self._conn.session_update(
+                session_id=self._id,
+                update=acp.schema.UserMessageChunk(
+                    content=content,
+                    session_update="user_message_chunk",
+                ),
+            )
+
     async def _send_thinking(self, think: str):
         """Send thinking content to client."""
         if not self._id or not self._conn:

{kimi_cli-1.44.0 → kimi_cli-1.46.0}/src/kimi_cli/app.py

@@ -27,6 +27,7 @@ from kimi_cli.soul import RunCancelled, run_soul
 from kimi_cli.soul.agent import Runtime, load_agent
 from kimi_cli.soul.context import Context
 from kimi_cli.soul.kimisoul import KimiSoul
+from kimi_cli.soul.toolset import KimiToolset
 from kimi_cli.utils.aioqueue import QueueShutDown
 from kimi_cli.utils.envvar import get_env_bool
 from kimi_cli.utils.logging import logger, open_original_stderr, redirect_stderr_to_logger
@@ -415,6 +416,15 @@ class KimiCLI:
         if self._bg_refresh_task is not None and not self._bg_refresh_task.done():
             self._bg_refresh_task.cancel()
 
+        # Close MCP client connections so stdio/WebSocket transports do not
+        # outlive the CLI process and trigger firewall warnings.
+        try:
+            toolset = self.soul.agent.toolset
+            if isinstance(toolset, KimiToolset):
+                await toolset.cleanup()
+        except (Exception, asyncio.CancelledError):
+            logger.warning("Error during toolset cleanup; continuing exit", exc_info=True)
+
         bg_config = self._runtime.config.background
         if bg_config.keep_alive_on_exit:
             return
@@ -652,6 +662,7 @@ class KimiCLI:
                     user_input,
                     _ui_loop_fn,
                     run_cancel_event,
+                    self._runtime.session.wire_file,
                     runtime=self._runtime,
                 )
             )
@@ -687,6 +698,8 @@ class KimiCLI:
         self, command: str | None = None, *, prefill_text: str | None = None
     ) -> bool:
         """Run the Kimi Code CLI instance with shell UI."""
+        from rich.text import Text
+
         from kimi_cli.ui.shell import Shell, WelcomeInfoItem
 
         if command is None:
@@ -758,11 +771,14 @@ class KimiCLI:
         welcome_info.append(
             WelcomeInfoItem(
                 name="\nTip",
-                value=(
-                    "Spot a bug or have feedback? Type /feedback right in this session"
-                    " — every report makes Kimi better."
+                value=Text.assemble(
+                    "We just released Kimi Code — our new coding agent. Check it out at ",
+                    Text(
+                        "https://www.kimi.com/code",
+                        style="link https://www.kimi.com/code underline",
+                    ),
                 ),
-                level=WelcomeInfoItem.Level.INFO,
+                level=WelcomeInfoItem.Level.WARN,
             )
         )
         async with self._env():

{kimi_cli-1.44.0 → kimi_cli-1.46.0}/src/kimi_cli/soul/toolset.py

@@ -11,7 +11,7 @@ from contextvars import ContextVar
 from dataclasses import dataclass
 from datetime import timedelta
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, overload
+from typing import TYPE_CHECKING, Any, Literal, cast, overload
 
 from kosong.tooling import (
     CallableTool,
@@ -83,6 +83,7 @@ def get_current_tool_call_or_none() -> ToolCall | None:
 
 
 type ToolType = CallableTool | CallableTool2[Any]
+type ToolCallKey = tuple[str, str]
 
 
 if TYPE_CHECKING:
@@ -91,7 +92,7 @@ if TYPE_CHECKING:
         _: Toolset = kimi_toolset
 
 
-_REMINDER_TEXT = (
+_REMINDER_TEXT_1 = (
     "\n\n<system-reminder>\n"
     "You are repeating the exact same tool call with identical parameters."
     " Please carefully analyze the previous result. If the task is not yet complete,"
@@ -100,7 +101,56 @@ _REMINDER_TEXT = (
 )
 
 
-def _append_reminder_to_return_value(return_value: Any) -> Any:
+def _make_reminder_text_2(tool_name: str, repeat_count: int, canonical_args: str) -> str:
+    return (
+        "\n\n<system-reminder>\n"
+        "You have repeatedly called the same tool with identical parameters many times.\n"
+        "Repeated tool call detected:\n"
+        f"- tool: {tool_name}\n"
+        f"- repeated_times: {repeat_count}\n"
+        f"- arguments: {canonical_args}\n"
+        "The previous repeated calls did not make progress. Do not call this exact same tool "
+        "with the exact same arguments again.\n"
+        "Carefully inspect the latest tool result and choose a different next action, "
+        "different parameters, or finish the task if enough evidence has been gathered."
+        "\n</system-reminder>"
+    )
+
+
+def _sort_json_value(value: object) -> object:
+    if isinstance(value, list):
+        return [_sort_json_value(item) for item in cast("list[object]", value)]
+    if isinstance(value, dict):
+        value_dict = cast("dict[str, object]", value)
+        return {key: _sort_json_value(value_dict[key]) for key in sorted(value_dict)}
+    return value
+
+
+def _canonical_tool_arguments(arguments: Any) -> str:
+    try:
+        return json.dumps(
+            _sort_json_value(arguments),
+            ensure_ascii=False,
+            separators=(",", ":"),
+        )
+    except (TypeError, ValueError):
+        return str(arguments)
+
+
+def _canonical_tool_arguments_text(arguments: str) -> str:
+    try:
+        return _canonical_tool_arguments(json.loads(arguments, strict=False))
+    except json.JSONDecodeError:
+        return arguments
+
+
+def _normalize_call_key(tool_name: str, arguments: str) -> ToolCallKey:
+    return (tool_name, _canonical_tool_arguments_text(arguments))
+
+
+def _append_reminder_to_return_value(
+    return_value: Any, reminder_text: str = _REMINDER_TEXT_1
+) -> Any:
     """Append dedup reminder text to a ToolReturnValue output."""
     from kosong.tooling import ToolReturnValue
 
@@ -108,16 +158,15 @@ def _append_reminder_to_return_value(return_value: Any) -> Any:
         return return_value
 
     output = return_value.output
-    reminder = _REMINDER_TEXT
 
     if isinstance(output, str):
-        new_output = output + reminder
+        new_output = output + reminder_text
     else:
         new_output = list(output)
         if new_output and isinstance(new_output[-1], TextPart):
-            new_output[-1] = TextPart(text=new_output[-1].text + reminder)
+            new_output[-1] = TextPart(text=new_output[-1].text + reminder_text)
         else:
-            new_output.append(TextPart(text=reminder))
+            new_output.append(TextPart(text=reminder_text))
 
     return return_value.model_copy(update={"output": new_output})
 
@@ -132,9 +181,13 @@ class KimiToolset:
         self._hook_engine: HookEngine = HookEngine()
 
         # Deduplication state
-        self._previous_step_calls: list[tuple[str, str]] = []
-        self._current_step_calls: list[tuple[str, str]] = []
-        self._current_step_tasks: dict[tuple[str, str], asyncio.Task[ToolResult]] = {}
+        self._previous_step_calls: list[ToolCallKey] = []
+        self._current_step_calls: list[ToolCallKey] = []
+        self._current_step_tasks: dict[ToolCallKey, asyncio.Task[ToolResult]] = {}
+        self._seen_call_keys: set[ToolCallKey] = set()
+        self._consecutive_key: ToolCallKey | None = None
+        self._consecutive_count: int = 0
+        self._step_closed: bool = False
         self._dedup_triggered: bool = False
         self._step_no: int = 0
         self._turn_id: str = ""
@@ -183,17 +236,51 @@ class KimiToolset:
         turn_id: str = "",
     ) -> None:
         """Called before each step to set up deduplication state."""
-        self._previous_step_calls = previous_calls
+        self._previous_step_calls = [
+            _normalize_call_key(tool_name, arguments) for tool_name, arguments in previous_calls
+        ]
         self._current_step_calls = []
         self._current_step_tasks = {}
+        self._step_closed = False
         self._dedup_triggered = False
         self._step_no = step_no
         self._turn_id = turn_id
+        if not self._previous_step_calls:
+            self._seen_call_keys = set()
+            self._consecutive_key = None
+            self._consecutive_count = 0
+        else:
+            self._seen_call_keys.update(self._previous_step_calls)
+            if self._consecutive_key is None and self._consecutive_count == 0:
+                self._advance_consecutive_streak(self._previous_step_calls)
 
     def end_step(self) -> list[tuple[str, str]]:
         """Called after each step to capture the calls made in this step."""
+        if not self._step_closed:
+            self._advance_consecutive_streak(self._current_step_calls)
+            self._seen_call_keys.update(self._current_step_calls)
+            self._step_closed = True
         return list(self._current_step_calls)
 
+    def _advance_consecutive_streak(self, calls: list[ToolCallKey]) -> None:
+        for call_key in calls:
+            if call_key == self._consecutive_key:
+                self._consecutive_count += 1
+            else:
+                self._consecutive_key = call_key
+                self._consecutive_count = 1
+
+    def _projected_streak_for_call(self, call_index: int) -> int:
+        consecutive_key = self._consecutive_key
+        consecutive_count = self._consecutive_count
+        for call_key in self._current_step_calls[: call_index + 1]:
+            if call_key == consecutive_key:
+                consecutive_count += 1
+            else:
+                consecutive_key = call_key
+                consecutive_count = 1
+        return consecutive_count
+
     @property
     def dedup_triggered(self) -> bool:
         """Whether a cross-step duplicate was blocked in the current step."""
@@ -202,9 +289,31 @@ class KimiToolset:
     def handle(self, tool_call: ToolCall) -> HandleResult:
         token = current_tool_call.set(tool_call)
         try:
-            call_key = (tool_call.function.name, tool_call.function.arguments or "{}")
+            tool_name = tool_call.function.name
 
-            # Same-step dedup: wait for the original task and copy its result
+            if tool_name not in self._tool_dict:
+                return ToolResult(
+                    tool_call_id=tool_call.id,
+                    return_value=ToolNotFoundError(tool_name),
+                )
+
+            try:
+                arguments: JsonType = json.loads(tool_call.function.arguments or "{}", strict=False)
+            except json.JSONDecodeError as e:
+                logger.warning(
+                    "Tool call JSON parse error: {tool_name} (call_id={call_id}): {error}",
+                    tool_name=tool_name,
+                    call_id=tool_call.id,
+                    error=e,
+                )
+                return ToolResult(tool_call_id=tool_call.id, return_value=ToolParseError(str(e)))
+
+            canonical_args = _canonical_tool_arguments(arguments)
+            call_key = (tool_name, canonical_args)
+            call_index = len(self._current_step_calls)
+            self._current_step_calls.append(call_key)
+
+            # Same-step dedup: wait for the original task and copy its result.
             if call_key in self._current_step_tasks:
                 from kimi_cli.telemetry import track
 
@@ -213,9 +322,9 @@ class KimiToolset:
                     session_id=_get_session_id(),
                     turn_id=self._turn_id,
                     step_no=self._step_no,
-                    tool_name=tool_call.function.name,
+                    tool_name=tool_name,
                     dup_type="same_step",
-                    args_hash=hashlib.sha256(call_key[1].encode()).hexdigest()[:8],
+                    args_hash=hashlib.sha256(canonical_args.encode()).hexdigest()[:8],
                 )
                 original_task = self._current_step_tasks[call_key]
 
@@ -228,7 +337,8 @@ class KimiToolset:
 
                 return asyncio.create_task(_await_dup())
 
-            is_cross_step_dup = call_key in self._previous_step_calls
+            is_cross_step_dup = call_key in self._seen_call_keys
+            reminder_text: str | None = None
             if is_cross_step_dup:
                 from kimi_cli.telemetry import track
 
@@ -237,30 +347,18 @@ class KimiToolset:
                     session_id=_get_session_id(),
                     turn_id=self._turn_id,
                     step_no=self._step_no,
-                    tool_name=tool_call.function.name,
+                    tool_name=tool_name,
                     dup_type="cross_step",
-                    args_hash=hashlib.sha256(call_key[1].encode()).hexdigest()[:8],
+                    args_hash=hashlib.sha256(canonical_args.encode()).hexdigest()[:8],
                 )
                 self._dedup_triggered = True
+                repeat_count = self._projected_streak_for_call(call_index)
+                if repeat_count == 3:
+                    reminder_text = _REMINDER_TEXT_1
+                elif repeat_count in (5, 8):
+                    reminder_text = _make_reminder_text_2(tool_name, repeat_count, canonical_args)
 
-            if tool_call.function.name not in self._tool_dict:
-                return ToolResult(
-                    tool_call_id=tool_call.id,
-                    return_value=ToolNotFoundError(tool_call.function.name),
-                )
-
-            tool = self._tool_dict[tool_call.function.name]
-
-            try:
-                arguments: JsonType = json.loads(tool_call.function.arguments or "{}", strict=False)
-            except json.JSONDecodeError as e:
-                logger.warning(
-                    "Tool call JSON parse error: {tool_name} (call_id={call_id}): {error}",
-                    tool_name=tool_call.function.name,
-                    call_id=tool_call.id,
-                    error=e,
-                )
-                return ToolResult(tool_call_id=tool_call.id, return_value=ToolParseError(str(e)))
+            tool = self._tool_dict[tool_name]
 
             async def _call():
                 tool_input_dict = arguments if isinstance(arguments, dict) else {}
@@ -270,11 +368,11 @@ class KimiToolset:
 
                 results = await self._hook_engine.trigger(
                     "PreToolUse",
-                    matcher_value=tool_call.function.name,
+                    matcher_value=tool_name,
                     input_data=events.pre_tool_use(
                         session_id=_get_session_id(),
                         cwd=str(Path.cwd()),
-                        tool_name=tool_call.function.name,
+                        tool_name=tool_name,
                         tool_input=tool_input_dict,
                         tool_call_id=tool_call.id,
                     ),
@@ -297,18 +395,18 @@ class KimiToolset:
                     tool_elapsed = time.monotonic() - t0
                     logger.exception(
                         "Tool execution failed: {tool_name} (call_id={call_id})",
-                        tool_name=tool_call.function.name,
+                        tool_name=tool_name,
                         call_id=tool_call.id,
                     )
                     # --- PostToolUseFailure (fire-and-forget) ---
                     _hook_task = asyncio.create_task(
                         self._hook_engine.trigger(
                             "PostToolUseFailure",
-                            matcher_value=tool_call.function.name,
+                            matcher_value=tool_name,
                             input_data=events.post_tool_use_failure(
                                 session_id=_get_session_id(),
                                 cwd=str(Path.cwd()),
-                                tool_name=tool_call.function.name,
+                                tool_name=tool_name,
                                 tool_input=tool_input_dict,
                                 error=str(e),
                                 tool_call_id=tool_call.id,
@@ -323,7 +421,7 @@ class KimiToolset:
                     _error_type = type(e).__name__
                     track(
                         "tool_call",
-                        tool_name=tool_call.function.name,
+                        tool_name=tool_name,
                         outcome="error",
                         duration_ms=int(tool_elapsed * 1000),
                         error_type=_error_type,
@@ -336,7 +434,7 @@ class KimiToolset:
                 tool_elapsed = time.monotonic() - t0
                 logger.info(
                     "Tool {tool_name} completed in {elapsed:.1f}s (call_id={call_id})",
-                    tool_name=tool_call.function.name,
+                    tool_name=tool_name,
                     elapsed=tool_elapsed,
                     call_id=tool_call.id,
                 )
@@ -345,7 +443,7 @@ class KimiToolset:
                 if isinstance(ret, ToolError):
                     _track_tool_call(
                         "tool_call",
-                        tool_name=tool_call.function.name,
+                        tool_name=tool_name,
                         outcome="error",
                         duration_ms=int(tool_elapsed * 1000),
                         error_type=type(ret).__name__,
@@ -354,7 +452,7 @@ class KimiToolset:
                 else:
                     _track_tool_call(
                         "tool_call",
-                        tool_name=tool_call.function.name,
+                        tool_name=tool_name,
                         outcome="success",
                         duration_ms=int(tool_elapsed * 1000),
                         dup_type="cross_step" if is_cross_step_dup else "normal",
@@ -364,11 +462,11 @@ class KimiToolset:
                 _hook_task = asyncio.create_task(
                     self._hook_engine.trigger(
                         "PostToolUse",
-                        matcher_value=tool_call.function.name,
+                        matcher_value=tool_name,
                         input_data=events.post_tool_use(
                             session_id=_get_session_id(),
                             cwd=str(Path.cwd()),
-                            tool_name=tool_call.function.name,
+                            tool_name=tool_name,
                             tool_input=tool_input_dict,
                             tool_output=str(ret)[:2000],
                             tool_call_id=tool_call.id,
@@ -380,21 +478,21 @@ class KimiToolset:
                 return ToolResult(tool_call_id=tool_call.id, return_value=ret)
 
             task = asyncio.create_task(_call())
-            if is_cross_step_dup:
+            if reminder_text is not None:
 
                 async def _wrap_with_reminder(
                     inner_task: asyncio.Task[ToolResult],
+                    text: str,
                 ) -> ToolResult:
                     tr = await inner_task
                     return ToolResult(
                         tool_call_id=tr.tool_call_id,
-                        return_value=_append_reminder_to_return_value(tr.return_value),
+                        return_value=_append_reminder_to_return_value(tr.return_value, text),
                     )
 
-                task = asyncio.create_task(_wrap_with_reminder(task))
+                task = asyncio.create_task(_wrap_with_reminder(task, reminder_text))
 
             self._current_step_tasks[call_key] = task
-            self._current_step_calls.append(call_key)
             return task
         finally:
             current_tool_call.reset(token)
@@ -674,11 +772,14 @@ class KimiToolset:
         self._deferred_mcp_load = None
         if self._mcp_loading_task:
             self._mcp_loading_task.cancel()
-            with contextlib.suppress(Exception):
+            with contextlib.suppress(Exception, asyncio.CancelledError):
                 await self._mcp_loading_task
         for server_info in self._mcp_servers.values():
             if server_info.client is not None:
-                await server_info.client.close()
+                try:
+                    await server_info.client.close()
+                except Exception:
+                    logger.warning("Failed to close MCP client", exc_info=True)
 
 
 @dataclass(slots=True)

{kimi_cli-1.44.0 → kimi_cli-1.46.0}/src/kimi_cli/ui/shell/__init__.py

@@ -971,10 +971,7 @@ class Shell:
                     f"[red]Membership expired, please renew your plan[/red]\n[dim]Server: {e}[/dim]"
                 )
             elif isinstance(e, APIStatusError) and e.status_code == 403:
-                console.print(
-                    "[red]Quota exceeded, please upgrade your plan or retry later[/red]\n"
-                    f"[dim]Server: {e}[/dim]"
-                )
+                console.print(f"[red]Server: {e}[/red]")
             elif isinstance(e, APIConnectionError):
                 console.print(
                     f"[red]Network connection failed: {e}[/red]\n"
@@ -1478,7 +1475,7 @@ class WelcomeInfoItem:
         ERROR = "red"
 
     name: str
-    value: str
+    value: str | Text
     level: Level = Level.INFO
 
 
@@ -1498,7 +1495,10 @@ def _print_welcome_info(name: str, info_items: list[WelcomeInfoItem]) -> None:
     if info_items:
         rows.append(Text(""))  # empty line
     for item in info_items:
-        rows.append(Text(f"{item.name}: {item.value}", style=item.level.value))
+        if isinstance(item.value, Text):
+            rows.append(Text.assemble(f"{item.name}: ", item.value, style=item.level.value))
+        else:
+            rows.append(Text(f"{item.name}: {item.value}", style=item.level.value))
 
     if LATEST_VERSION_FILE.exists():
         from kimi_cli.constant import VERSION as current_version