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

kimi_cli/CHANGELOG.md

@@ -9,6 +9,29 @@ Internal builds may append content to the Unreleased section.
 Only write entries that are worth mentioning to users.
 -->
 
+## [0.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
+
+- Allow `KIMI_MODEL_CAPABILITIES` environment variable to override model capabilities
+- Add `--no-markdown` option to disable markdown rendering
+- Support `openai_responses` LLM provider type
+
+### Fixed
+
+- Fix crash when continuing a session
+
 ## [0.44] - 2025-10-30
 
 ### Changed

kimi_cli/app.py

@@ -127,7 +127,7 @@ class KimiCLI:
         finally:
             os.chdir(original_cwd)
 
-    async def run_shell_mode(self, command: str | None = None) -> bool:
+    async def run_shell_mode(self, command: str | None = None, markdown: bool = True) -> bool:
         from kimi_cli.ui.shell import ShellApp, WelcomeInfoItem
 
         welcome_info = [
@@ -167,7 +167,7 @@ class KimiCLI:
                 )
             )
         with self._app_env():
-            app = ShellApp(self._soul, welcome_info=welcome_info)
+            app = ShellApp(self._soul, welcome_info=welcome_info, markdown=markdown)
             return await app.run(command)
 
     async def run_print_mode(
@@ -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"]
 
@@ -137,6 +137,12 @@ OutputFormat = Literal["text", "stream-json"]
     default=False,
     help="Automatically approve all actions. Default: no.",
 )
+@click.option(
+    "--markdown/--no-markdown",
+    is_flag=True,
+    default=True,
+    help="Enable/disable markdown rendering in shell UI. Default: yes.",
+)
 def kimi(
     verbose: bool,
     debug: bool,
@@ -151,6 +157,7 @@ def kimi(
     mcp_config_file: list[Path],
     mcp_config: list[str],
     yolo: bool,
+    markdown: bool,
 ):
     """Kimi, your next CLI agent."""
     from kimi_cli.app import KimiCLI
@@ -163,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",
     )
@@ -220,7 +230,7 @@ def kimi(
         )
         match ui:
             case "shell":
-                return await instance.run_shell_mode(command)
+                return await instance.run_shell_mode(command, markdown=markdown)
             case "print":
                 return await instance.run_print_mode(
                     input_format or "text",
@@ -231,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", "_chaos"]
+    type: Literal["kimi", "openai_legacy", "openai_responses", "anthropic", "_chaos"]
     """Provider type"""
     base_url: str
     """API base URL"""

kimi_cli/llm.py

@@ -1,5 +1,5 @@
 import os
-from typing import NamedTuple
+from typing import NamedTuple, cast, get_args
 
 from kosong.base.chat_provider import ChatProvider
 from pydantic import SecretStr
@@ -41,11 +41,19 @@ def augment_provider_with_env_vars(provider: LLMProvider, model: LLMModel) -> di
                 applied["KIMI_API_KEY"] = "******"
             if model_name := os.getenv("KIMI_MODEL_NAME"):
                 model.model = model_name
-                applied["KIMI_MODEL_NAME"] = model.model
+                applied["KIMI_MODEL_NAME"] = model_name
             if max_context_size := os.getenv("KIMI_MODEL_MAX_CONTEXT_SIZE"):
                 model.max_context_size = int(max_context_size)
-                applied["KIMI_MODEL_MAX_CONTEXT_SIZE"] = str(model.max_context_size)
-        case "openai_legacy":
+                applied["KIMI_MODEL_MAX_CONTEXT_SIZE"] = max_context_size
+            if capabilities := os.getenv("KIMI_MODEL_CAPABILITIES"):
+                caps_lower = (cap.strip().lower() for cap in capabilities.split(",") if cap.strip())
+                model.capabilities = set(
+                    cast(LLMModelCapability, cap)
+                    for cap in caps_lower
+                    if cap in get_args(LLMModelCapability)
+                )
+                applied["KIMI_MODEL_CAPABILITIES"] = capabilities
+        case "openai_legacy" | "openai_responses":
             if base_url := os.getenv("OPENAI_BASE_URL"):
                 provider.base_url = base_url
             if api_key := os.getenv("OPENAI_API_KEY"):
@@ -88,6 +96,29 @@ def create_llm(
                 api_key=provider.api_key.get_secret_value(),
                 stream=stream,
             )
+        case "openai_responses":
+            from kosong.chat_provider.openai_responses import OpenAIResponses
+
+            chat_provider = OpenAIResponses(
+                model=model.model,
+                base_url=provider.base_url,
+                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/shell/__init__.py

@@ -24,10 +24,16 @@ from kimi_cli.utils.signals import install_sigint_handler
 
 
 class ShellApp:
-    def __init__(self, soul: Soul, welcome_info: list["WelcomeInfoItem"] | None = None):
+    def __init__(
+        self,
+        soul: Soul,
+        welcome_info: list["WelcomeInfoItem"] | None = None,
+        markdown: bool = True,
+    ):
         self.soul = soul
         self._welcome_info = list(welcome_info or [])
         self._background_tasks: set[asyncio.Task[Any]] = set()
+        self._markdown = markdown
 
     async def run(self, command: str | None = None) -> bool:
         if command is not None:
@@ -168,7 +174,10 @@ class ShellApp:
                 self.soul,
                 user_input,
                 lambda wire: visualize(
-                    wire, initial_status=self.soul.status, cancel_event=cancel_event
+                    wire,
+                    initial_status=self.soul.status,
+                    cancel_event=cancel_event,
+                    markdown=self._markdown,
                 ),
                 cancel_event,
             )

kimi_cli/ui/shell/liveview.py

@@ -1,5 +1,6 @@
 import asyncio
 from collections import deque
+from typing import Literal
 
 import streamingjson
 from kosong.base.message import ToolCall, ToolCallPart
@@ -129,6 +130,7 @@ class StepLiveView:
     def __init__(self, status: StatusSnapshot, cancel_event: asyncio.Event | None = None):
         # message content
         self._line_buffer = Text("")
+        self._last_text_mode: Literal["text", "think", ""] = ""
 
         # tool call
         self._tool_calls: dict[str, _ToolCallDisplay] = {}
@@ -187,7 +189,21 @@ class StepLiveView:
         """
         console.print(renderable)
 
-    def append_text(self, text: str):
+    def append_text(self, text: str, mode: Literal["text", "think"] = "text"):
+        if not text:
+            # Ignore empty message
+            return
+        if self._last_text_mode != mode:
+            if self._line_buffer:
+                self._push_out(self._line_buffer)
+                self._push_out("")  # Add extra line between different modes
+                self._line_buffer.plain = ""
+            self._last_text_mode = mode
+            match mode:
+                case "text":
+                    self._line_buffer.style = ""
+                case "think":
+                    self._line_buffer.style = "grey50 italic"
         lines = text.split("\n")
         prev_is_empty = not self._line_buffer
         for line in lines[:-1]:
@@ -313,7 +329,14 @@ class StepLiveViewWithMarkdown(StepLiveView):
         self._buffer_status_active = False
         self._buffer_status_obj: Status | None = None
 
-    def append_text(self, text: str):
+    def append_text(self, text: str, mode: Literal["text", "think"] = "text"):
+        if not text:
+            # Ignore empty message
+            return
+        if self._last_text_mode != mode:
+            if self._flush_markdown():
+                self._push_out("")  # Add extra line between different modes
+            self._last_text_mode = mode
         if not self._pending_markdown_parts:
             self._show_thinking_status()
         self._pending_markdown_parts.append(text)
@@ -334,14 +357,22 @@ class StepLiveViewWithMarkdown(StepLiveView):
         self._flush_markdown()
         return super().__exit__(exc_type, exc_value, traceback)
 
-    def _flush_markdown(self):
+    def _flush_markdown(self) -> bool:
         self._hide_thinking_status()
         if not self._pending_markdown_parts:
-            return
+            return False
         markdown_text = "".join(self._pending_markdown_parts)
         self._pending_markdown_parts.clear()
         if markdown_text.strip():
-            self._push_out(_LeftAlignedMarkdown(markdown_text, justify="left"))
+            self._push_out(
+                _LeftAlignedMarkdown(
+                    markdown_text,
+                    justify="left",
+                    style="grey50 italic" if self._last_text_mode == "think" else "none",
+                )
+            )
+            return True
+        return False
 
     def _show_thinking_status(self):
         if self._buffer_status_active: