klaude-code 1.2.28__tar.gz → 1.2.30__tar.gz

{klaude_code-1.2.28 → klaude_code-1.2.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.28
+Version: 1.2.30
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0

{klaude_code-1.2.28 → klaude_code-1.2.30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.2.28"
+version = "1.2.30"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/cli/config_cmd.py

@@ -6,7 +6,7 @@ import sys
 
 import typer
 
-from klaude_code.config import config_path, load_config
+from klaude_code.config import config_path, create_example_config, example_config_path, load_config
 from klaude_code.trace import log
 
 
@@ -57,17 +57,24 @@ def edit_config() -> None:
         else:  # Linux and other Unix systems
             editor = "xdg-open"
 
-    # Ensure config file exists
-    load_config()
+    # Ensure config directory exists and create example config if needed
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    if create_example_config():
+        log(f"Created example config: {example_config_path}", style="dim")
+
+    # Decide which file to open
+    target_path = config_path if config_path.exists() else example_config_path
+    if target_path == example_config_path:
+        log(f"Opening example config (copy to {config_path.name} to use)", style="yellow")
 
     try:
         if editor == "open -a TextEdit":
-            subprocess.run(["open", "-a", "TextEdit", str(config_path)], check=True)
+            subprocess.run(["open", "-a", "TextEdit", str(target_path)], check=True)
         elif editor in ["open", "xdg-open"]:
             # For open/xdg-open, we need to pass the file directly
-            subprocess.run([editor, str(config_path)], check=True)
+            subprocess.run([editor, str(target_path)], check=True)
         else:
-            subprocess.run([editor, str(config_path)], check=True)
+            subprocess.run([editor, str(target_path)], check=True)
     except subprocess.CalledProcessError as e:
         log((f"Error: Failed to open editor: {e}", "red"))
         raise typer.Exit(1) from None

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/cli/list_model.py

@@ -218,7 +218,7 @@ def display_models_and_providers(config: Config):
 
         panel = Panel(
             panel_content,
-            title=Text(f"Provider: {provider.provider_name}", style="white bold"),
+            title=Text(f"Provider: {provider.provider_name}", style=ThemeKey.CONFIG_PROVIDER),
             border_style=ThemeKey.CONFIG_PANEL_BORDER,
             padding=(0, 1),
             title_align="left",

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/command/__init__.py

@@ -36,6 +36,7 @@ def ensure_commands_loaded() -> None:
     from .model_cmd import ModelCommand
     from .refresh_cmd import RefreshTerminalCommand
     from .release_notes_cmd import ReleaseNotesCommand
+    from .resume_cmd import ResumeCommand
     from .status_cmd import StatusCommand
     from .terminal_setup_cmd import TerminalSetupCommand
     from .thinking_cmd import ThinkingCommand
@@ -47,6 +48,7 @@ def ensure_commands_loaded() -> None:
     register(ThinkingCommand())
     register(ModelCommand())
     register(ForkSessionCommand())
+    register(ResumeCommand())
     load_prompt_commands()
     register(StatusCommand())
     register(HelpCommand())
@@ -70,6 +72,7 @@ def __getattr__(name: str) -> object:
         "ModelCommand": "model_cmd",
         "RefreshTerminalCommand": "refresh_cmd",
         "ReleaseNotesCommand": "release_notes_cmd",
+        "ResumeCommand": "resume_cmd",
         "StatusCommand": "status_cmd",
         "TerminalSetupCommand": "terminal_setup_cmd",
         "ThinkingCommand": "thinking_cmd",

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/command/clear_cmd.py

@@ -15,4 +15,7 @@ class ClearCommand(CommandABC):
 
     async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
         del user_input  # unused
-        return CommandResult(operations=[op.ClearSessionOperation(session_id=agent.session.id)])
+        return CommandResult(
+            operations=[op.ClearSessionOperation(session_id=agent.session.id)],
+            persist_user_input=False,
+        )

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/command/command_abc.py

@@ -42,6 +42,10 @@ class CommandResult(BaseModel):
     ) = None  # List of UI events to display immediately
     operations: list[op.Operation] | None = None
 
+    # Persistence controls: some slash commands are UI/control actions and should not be written to session history.
+    persist_user_input: bool = True
+    persist_events: bool = True
+
 
 class CommandABC(ABC):
     """Abstract base class for slash commands."""

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/command/fork_session_cmd.py

@@ -24,7 +24,7 @@ class ForkSessionCommand(CommandABC):
                     command_output=model.CommandOutput(command_name=self.name),
                 ),
             )
-            return CommandResult(events=[event])
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
 
         new_session = agent.session.fork()
         await new_session.wait_for_flush()
@@ -39,4 +39,4 @@ class ForkSessionCommand(CommandABC):
                 ),
             ),
         )
-        return CommandResult(events=[event])
+        return CommandResult(events=[event], persist_user_input=False, persist_events=False)

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/command/model_cmd.py

@@ -1,9 +1,43 @@
 import asyncio
 
+import questionary
+
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.config.select_model import select_model_from_config
 from klaude_code.protocol import commands, events, model, op
 
+SELECT_STYLE = questionary.Style(
+    [
+        ("instruction", "ansibrightblack"),
+        ("pointer", "ansicyan"),
+        ("highlighted", "ansicyan"),
+        ("text", "ansibrightblack"),
+    ]
+)
+
+
+def _confirm_change_default_model_sync(selected_model: str) -> bool:
+    choices: list[questionary.Choice] = [
+        questionary.Choice(title="No (session only)", value=False),
+        questionary.Choice(title="Yes (save as default)", value=True),
+    ]
+
+    try:
+        # Add a blank line between the model selector and this confirmation prompt.
+        questionary.print("")
+        result = questionary.select(
+            message=f"Save '{selected_model}' as default model (main_model)?",
+            choices=choices,
+            pointer="→",
+            instruction="Use arrow keys to move, Enter to select",
+            use_jk_keys=False,
+            style=SELECT_STYLE,
+        ).ask()
+    except KeyboardInterrupt:
+        return False
+
+    return bool(result)
+
 
 class ModelCommand(CommandABC):
     """Display or change the model configuration."""
@@ -44,7 +78,13 @@ class ModelCommand(CommandABC):
                     )
                 ]
             )
-
+        save_as_default = await asyncio.to_thread(_confirm_change_default_model_sync, selected_model)
         return CommandResult(
-            operations=[op.ChangeModelOperation(session_id=agent.session.id, model_name=selected_model)]
+            operations=[
+                op.ChangeModelOperation(
+                    session_id=agent.session.id,
+                    model_name=selected_model,
+                    save_as_default=save_as_default,
+                )
+            ]
         )

klaude_code-1.2.30/src/klaude_code/command/resume_cmd.py

@@ -0,0 +1,51 @@
+import asyncio
+
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, events, model, op
+from klaude_code.session.selector import resume_select_session
+
+
+class ResumeCommand(CommandABC):
+    """Resume a previous session."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.RESUME
+
+    @property
+    def summary(self) -> str:
+        return "Resume a previous session"
+
+    @property
+    def is_interactive(self) -> bool:
+        return True
+
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
+
+        if agent.session.messages_count > 0:
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="Cannot resume: current session already has messages. Use `klaude -r` to start a new instance with session selection.",
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        selected_session_id = await asyncio.to_thread(resume_select_session)
+        if selected_session_id is None:
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="(no session selected)",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        return CommandResult(
+            operations=[op.ResumeSessionOperation(target_session_id=selected_session_id)],
+            persist_user_input=False,
+            persist_events=False,
+        )

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/command/status_cmd.py

@@ -152,4 +152,4 @@ class StatusCommand(CommandABC):
             ),
         )
 
-        return CommandResult(events=[event])
+        return CommandResult(events=[event], persist_user_input=False, persist_events=False)

klaude_code-1.2.30/src/klaude_code/config/__init__.py

@@ -0,0 +1,19 @@
+from .config import (
+    Config,
+    UserConfig,
+    config_path,
+    create_example_config,
+    example_config_path,
+    load_config,
+    print_no_available_models_hint,
+)
+
+__all__ = [
+    "Config",
+    "UserConfig",
+    "config_path",
+    "create_example_config",
+    "example_config_path",
+    "load_config",
+    "print_no_available_models_hint",
+]

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/config/assets/builtin_config.yaml

@@ -53,6 +53,17 @@ provider_list:
   protocol: openrouter
   api_key: ${OPENROUTER_API_KEY}
   model_list:
+  - model_name: gpt-5-mini
+    model_params:
+      model: openai/gpt-5-mini
+      max_tokens: 128000
+      context_limit: 400000
+      thinking:
+        reasoning_effort: high
+      cost:
+        input: 0.25
+        output: 2.0
+        cache_read: 0.03
   - model_name: gpt-5.1-codex-max
     model_params:
       model: openai/gpt-5.1-codex-max

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/config/config.py

@@ -51,6 +51,7 @@ def resolve_api_key(value: str | None) -> str | None:
 
 
 config_path = Path.home() / ".klaude" / "klaude-config.yaml"
+example_config_path = Path.home() / ".klaude" / "klaude-config.example.yaml"
 
 
 class ModelConfig(BaseModel):
@@ -227,8 +228,8 @@ class Config(BaseModel):
 def get_example_config() -> UserConfig:
     """Generate example config for user reference (will be commented out)."""
     return UserConfig(
-        main_model="my-model",
-        sub_agent_models={"explore": "fast-model", "oracle": "smart-model", "webagent": "fast-model", "task": "opus"},
+        main_model="opus",
+        sub_agent_models={"explore": "haiku", "oracle": "gpt-5.2", "webagent": "sonnet", "task": "sonnet"},
         provider_list=[
             UserProviderConfig(
                 provider_name="my-provider",
@@ -357,30 +358,32 @@ def _load_user_config() -> UserConfig | None:
         raise ValueError(f"Invalid config file: {config_path}") from e
 
 
-def _ensure_config_file_exists() -> None:
-    """Ensure config file exists with commented example."""
-    if config_path.exists():
-        return
+def create_example_config() -> bool:
+    """Create example config file if it doesn't exist.
+
+    Returns:
+        True if file was created, False if it already exists.
+    """
+    if example_config_path.exists():
+        return False
 
     example_config = get_example_config()
-    config_path.parent.mkdir(parents=True, exist_ok=True)
+    example_config_path.parent.mkdir(parents=True, exist_ok=True)
     config_dict = example_config.model_dump(mode="json", exclude_none=True)
 
-    # Comment out all example config lines
     yaml_str = yaml.dump(config_dict, default_flow_style=False, sort_keys=False) or ""
-    commented_yaml = "# Custom configuration (optional)\n"
-    commented_yaml += "# Built-in providers (anthropic, openai, openrouter, deepseek) are available automatically.\n"
-    commented_yaml += "# Just set the corresponding API key environment variable to use them.\n"
-    commented_yaml += "#\n"
-    commented_yaml += "# Example custom provider:\n"
-    commented_yaml += "\n".join(f"# {line}" if line.strip() else "#" for line in yaml_str.splitlines())
-    _ = config_path.write_text(commented_yaml)
+    header = "# Example configuration for klaude-code\n"
+    header += "# Copy this file to klaude-config.yaml and modify as needed.\n"
+    header += "# Run `klaude list` to see available models.\n"
+    header += "#\n"
+    header += "# Built-in providers (anthropic, openai, openrouter, deepseek) are available automatically.\n"
+    header += "# Just set the corresponding API key environment variable to use them.\n\n"
+    _ = example_config_path.write_text(header + yaml_str)
+    return True
 
 
 def _load_config_uncached() -> Config:
     """Load and merge builtin + user config. Always returns a valid Config."""
-    _ensure_config_file_exists()
-
     builtin_config = _get_builtin_config()
     user_config = _load_user_config()
 
@@ -417,6 +420,7 @@ def print_no_available_models_hint() -> None:
             log(f"  export {env_var}=<your-api-key>", style="dim")
     log("")
     log(f"Or add custom providers in: {config_path}", style="dim")
+    log(f"See example config: {example_config_path}", style="dim")
 
 
 # Expose cache control for tests and callers that need to invalidate the cache.

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/core/executor.py

@@ -203,13 +203,15 @@ class ExecutorContext:
             raise ValueError("Multiple RunAgentOperation results are not supported")
 
         persisted_user_input = run_ops[0].input if run_ops else user_input
-        agent.session.append_history(
-            [model.UserMessageItem(content=persisted_user_input.text, images=persisted_user_input.images)]
-        )
+
+        if result.persist_user_input:
+            agent.session.append_history(
+                [model.UserMessageItem(content=persisted_user_input.text, images=persisted_user_input.images)]
+            )
 
         if result.events:
             for evt in result.events:
-                if isinstance(evt, events.DeveloperMessageEvent):
+                if result.persist_events and isinstance(evt, events.DeveloperMessageEvent):
                     agent.session.append_history([evt.item])
                 await self.emit_event(evt)
 
@@ -237,12 +239,13 @@ class ExecutorContext:
         agent.session.model_config_name = operation.model_name
         agent.session.model_thinking = llm_config.thinking
 
-        # Save the selection as default main_model
-        config.main_model = operation.model_name
-        await config.save()
+        if operation.save_as_default:
+            config.main_model = operation.model_name
+            await config.save()
 
+        default_note = " (saved as default)" if operation.save_as_default else ""
         developer_item = model.DeveloperMessageItem(
-            content=f"Switched to: {llm_config.model}",
+            content=f"Switched to: {llm_config.model}{default_note}",
             command_output=model.CommandOutput(command_name=commands.CommandName.MODEL),
         )
         agent.session.append_history([developer_item])
@@ -305,6 +308,37 @@ class ExecutorContext:
         )
         await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
 
+    async def handle_resume_session(self, operation: op.ResumeSessionOperation) -> None:
+        target_session = Session.load(operation.target_session_id)
+        if (
+            target_session.model_thinking is not None
+            and target_session.model_name
+            and target_session.model_name == self.llm_clients.main.model_name
+        ):
+            self.llm_clients.main.get_llm_config().thinking = target_session.model_thinking
+
+        profile = self.model_profile_provider.build_profile(self.llm_clients.main)
+        from klaude_code.core.agent import Agent
+
+        agent = Agent(session=target_session, profile=profile)
+
+        async for evt in agent.replay_history():
+            await self.emit_event(evt)
+
+        await self.emit_event(
+            events.WelcomeEvent(
+                work_dir=str(target_session.work_dir),
+                llm_config=self.llm_clients.main.get_llm_config(),
+            )
+        )
+
+        self._agent = agent
+        log_debug(
+            f"Resumed session: {target_session.id}",
+            style="cyan",
+            debug_type=DebugType.EXECUTION,
+        )
+
     async def handle_export_session(self, operation: op.ExportSessionOperation) -> None:
         agent = await self._ensure_agent(operation.session_id)
         try:

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/core/task.py

@@ -238,12 +238,13 @@ class TaskExecutor:
                 return
 
             if turn is None or turn.task_finished:
-                # Sub-agent with empty result should retry instead of finishing
-                if ctx.sub_agent_state is not None and turn is not None and not turn.task_result.strip():
-                    yield events.ErrorEvent(
-                        error_message="Sub-agent returned empty result, retrying...",
-                        can_retry=True,
-                    )
+                # Empty result should retry instead of finishing
+                if turn is not None and not turn.task_result.strip():
+                    if ctx.sub_agent_state is not None:
+                        error_msg = "Sub-agent returned empty result, retrying..."
+                    else:
+                        error_msg = "Agent returned empty result, retrying..."
+                    yield events.ErrorEvent(error_message=error_msg, can_retry=True)
                     continue
                 break
 

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/core/tool/shell/bash_tool.py

@@ -334,7 +334,9 @@ class BashTool(ToolABC):
                 _best_effort_update_file_tracker(args.command)
                 return model.ToolResultItem(
                     status="success",
-                    output=output.strip(),
+                    # Preserve leading whitespace for tools like `nl -ba`.
+                    # Only trim trailing newlines to avoid adding an extra blank line in the UI.
+                    output=output.rstrip("\n"),
                 )
             else:
                 combined = ""
@@ -346,7 +348,8 @@ class BashTool(ToolABC):
                     combined = f"Command exited with code {rc}"
                 return model.ToolResultItem(
                     status="error",
-                    output=combined.strip(),
+                    # Preserve leading whitespace; only trim trailing newlines.
+                    output=combined.rstrip("\n"),
                 )
         except FileNotFoundError:
             return model.ToolResultItem(

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/core/tool/web/mermaid_tool.py

@@ -11,7 +11,7 @@ from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, model, tools
 
-_MERMAID_LIVE_PREFIX = "https://mermaid.live/edit#pako:"
+_MERMAID_LIVE_PREFIX = "https://mermaid.live/view#pako:"
 
 
 @register(tools.MERMAID)
@@ -49,7 +49,7 @@ class MermaidTool(ToolABC):
 
         link = cls._build_link(args.code)
         line_count = cls._count_lines(args.code)
-        ui_extra = model.MermaidLinkUIExtra(link=link, line_count=line_count)
+        ui_extra = model.MermaidLinkUIExtra(code=args.code, link=link, line_count=line_count)
         output = f"Mermaid diagram rendered successfully ({line_count} lines)."
         return model.ToolResultItem(status="success", output=output, ui_extra=ui_extra)
 

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/protocol/commands.py

@@ -16,6 +16,7 @@ class CommandName(str, Enum):
     RELEASE_NOTES = "release-notes"
     THINKING = "thinking"
     FORK_SESSION = "fork-session"
+    RESUME = "resume"
     # PLAN and DOC are dynamically registered now, but kept here if needed for reference
     # or we can remove them if no code explicitly imports them.
     # PLAN = "plan"

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/protocol/model.py

@@ -127,6 +127,7 @@ class SessionIdUIExtra(BaseModel):
 
 class MermaidLinkUIExtra(BaseModel):
     type: Literal["mermaid_link"] = "mermaid_link"
+    code: str = ""
     link: str
     line_count: int
 

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/protocol/op.py

@@ -27,6 +27,7 @@ class OperationType(Enum):
     CHANGE_MODEL = "change_model"
     CHANGE_THINKING = "change_thinking"
     CLEAR_SESSION = "clear_session"
+    RESUME_SESSION = "resume_session"
     EXPORT_SESSION = "export_session"
     INTERRUPT = "interrupt"
     INIT_AGENT = "init_agent"
@@ -73,6 +74,7 @@ class ChangeModelOperation(Operation):
     type: OperationType = OperationType.CHANGE_MODEL
     session_id: str
     model_name: str
+    save_as_default: bool = False
 
     async def execute(self, handler: OperationHandler) -> None:
         await handler.handle_change_model(self)
@@ -98,6 +100,16 @@ class ClearSessionOperation(Operation):
         await handler.handle_clear_session(self)
 
 
+class ResumeSessionOperation(Operation):
+    """Operation for resuming a different session."""
+
+    type: OperationType = OperationType.RESUME_SESSION
+    target_session_id: str
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_resume_session(self)
+
+
 class ExportSessionOperation(Operation):
     """Operation for exporting a session transcript to HTML."""
 

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/protocol/op_handler.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING:
         ExportSessionOperation,
         InitAgentOperation,
         InterruptOperation,
+        ResumeSessionOperation,
         RunAgentOperation,
         UserInputOperation,
     )
@@ -44,6 +45,10 @@ class OperationHandler(Protocol):
         """Handle a clear session operation."""
         ...
 
+    async def handle_resume_session(self, operation: ResumeSessionOperation) -> None:
+        """Handle a resume session operation."""
+        ...
+
     async def handle_export_session(self, operation: ExportSessionOperation) -> None:
         """Handle an export session operation."""
         ...

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/session/export.py

@@ -421,12 +421,6 @@ def _render_diff_span(span: model.DiffSpan, line_kind: str) -> str:
     return f'<span class="diff-span">{text}</span>'
 
 
-def _get_diff_ui_extra(ui_extra: model.ToolResultUIExtra | None) -> model.DiffUIExtra | None:
-    if isinstance(ui_extra, model.DiffUIExtra):
-        return ui_extra
-    return None
-
-
 def _render_markdown_doc(doc: model.MarkdownDocUIExtra) -> str:
     encoded = _escape_html(doc.content)
     file_path = _escape_html(doc.file_path)
@@ -481,21 +475,28 @@ def _build_add_only_diff(text: str, file_path: str) -> model.DiffUIExtra:
 def _get_mermaid_link_html(
     ui_extra: model.ToolResultUIExtra | None, tool_call: model.ToolCallItem | None = None
 ) -> str | None:
-    if tool_call and tool_call.name == "Mermaid":
+    code = ""
+    link: str | None = None
+    line_count = 0
+
+    if isinstance(ui_extra, model.MermaidLinkUIExtra):
+        code = ui_extra.code
+        link = ui_extra.link
+        line_count = ui_extra.line_count
+
+    if not code and tool_call and tool_call.name == "Mermaid":
         try:
             args = json.loads(tool_call.arguments)
             code = args.get("code", "")
         except (json.JSONDecodeError, TypeError):
             code = ""
-    else:
-        code = ""
+        line_count = code.count("\n") + 1 if code else 0
 
-    if not code and not isinstance(ui_extra, model.MermaidLinkUIExtra):
+    if not code and not link:
         return None
 
     # Prepare code for rendering and copy
     escaped_code = _escape_html(code) if code else ""
-    line_count = code.count("\n") + 1 if code else 0
 
     # Build Toolbar
     toolbar_items: list[str] = []
@@ -512,8 +513,6 @@ def _get_mermaid_link_html(
             '<button type="button" class="fullscreen-mermaid-btn" title="View Fullscreen">Fullscreen</button>'
         )
 
-    link = ui_extra.link if isinstance(ui_extra, model.MermaidLinkUIExtra) else None
-
     if link:
         link_url = _escape_html(link)
         buttons_html.append(

{klaude_code-1.2.28 → klaude_code-1.2.30}/src/klaude_code/session/session.py

@@ -213,7 +213,7 @@ class Session(BaseModel):
         forked.file_tracker = {k: v.model_copy(deep=True) for k, v in self.file_tracker.items()}
         forked.todos = [todo.model_copy(deep=True) for todo in self.todos]
 
-        items = [cast(model.ConversationItem, it.model_copy(deep=True)) for it in self.conversation_history]
+        items = [it.model_copy(deep=True) for it in self.conversation_history]
         if items:
             forked.append_history(items)
 
@@ -246,7 +246,7 @@ class Session(BaseModel):
     def need_turn_start(self, prev_item: model.ConversationItem | None, item: model.ConversationItem) -> bool:
         if not isinstance(
             item,
-            model.ReasoningEncryptedItem | model.ReasoningTextItem | model.AssistantMessageItem | model.ToolCallItem,
+            model.ReasoningTextItem | model.AssistantMessageItem | model.ToolCallItem,
         ):
             return False
         if prev_item is None: