klaude-code 2.1.1__py3-none-any.whl → 2.2.0__py3-none-any.whl

klaude_code/app/__init__.py

@@ -4,9 +4,8 @@ This package coordinates core execution (Executor) with frontend displays.
 Terminal-specific rendering and input handling live in `klaude_code.tui`.
 """
 
-from .runtime import AppInitConfig, run_exec
+from .runtime import AppInitConfig
 
 __all__ = [
     "AppInitConfig",
-    "run_exec",
 ]

klaude_code/app/runtime.py

@@ -9,12 +9,15 @@ import typer
 from klaude_code import ui
 from klaude_code.config import Config, load_config
 from klaude_code.core.agent import Agent
-from klaude_code.core.agent_profile import DefaultModelProfileProvider, VanillaModelProfileProvider
+from klaude_code.core.agent_profile import (
+    DefaultModelProfileProvider,
+    NanoBananaModelProfileProvider,
+    VanillaModelProfileProvider,
+)
 from klaude_code.core.executor import Executor
 from klaude_code.core.manager import build_llm_clients
 from klaude_code.log import DebugType, log, set_debug_logging
 from klaude_code.protocol import events, op
-from klaude_code.protocol.message import UserInputPayload
 from klaude_code.session.session import Session, close_default_store
 
 
@@ -25,8 +28,8 @@ class AppInitConfig:
     model: str | None
     debug: bool
     vanilla: bool
+    banana: bool
     debug_filters: set[DebugType] | None = None
-    stream_json: bool = False
 
 
 @dataclass
@@ -52,6 +55,20 @@ async def initialize_app_components(
 
     config = load_config()
 
+    if init_config.banana:
+        # Banana mode is strict: it requires the built-in Nano Banana image model to be available.
+        required_model = "nano-banana-pro@or"
+        available = {m.model_name for m in config.iter_model_entries(only_available=True)}
+        if required_model not in available:
+            log(
+                (
+                    f"Error: --banana requires model '{required_model}', but it is not available in the current environment",
+                    "red",
+                )
+            )
+            log(("Hint: set OPENROUTER_API_KEY (Nano Banana Pro is configured via OpenRouter by default)", "yellow"))
+            raise typer.Exit(2)
+
     try:
         llm_clients = build_llm_clients(
             config,
@@ -70,7 +87,12 @@ async def initialize_app_components(
             log((f"Error: failed to load the default model configuration: {exc}", "red"))
         raise typer.Exit(2) from None
 
-    model_profile_provider = VanillaModelProfileProvider() if init_config.vanilla else DefaultModelProfileProvider()
+    if init_config.banana:
+        model_profile_provider = NanoBananaModelProfileProvider()
+    elif init_config.vanilla:
+        model_profile_provider = VanillaModelProfileProvider()
+    else:
+        model_profile_provider = DefaultModelProfileProvider()
 
     event_queue: asyncio.Queue[events.Event] = asyncio.Queue()
 
@@ -176,40 +198,3 @@ async def handle_keyboard_interrupt(executor: Executor) -> None:
         log(("Resume with:", "dim"), (f"klaude --resume-by-id {session_id}", "green"))
     with contextlib.suppress(Exception):
         await executor.submit(op.InterruptOperation(target_session_id=None))
-
-
-async def run_exec(init_config: AppInitConfig, input_content: str) -> None:
-    """Run a single task non-interactively (exec mode)."""
-    from klaude_code.ui.terminal.title import update_terminal_title
-
-    display = ui.create_exec_display(debug=init_config.debug, stream_json=init_config.stream_json)
-    components = await initialize_app_components(
-        init_config=init_config,
-        display=display,
-        on_model_change=update_terminal_title,
-    )
-
-    try:
-        session_id = await initialize_session(components.executor, components.event_queue)
-        backfill_session_model_config(
-            components.executor.context.current_agent,
-            init_config.model,
-            components.config.main_model,
-            is_new_session=True,
-        )
-
-        if session_id is None:
-            raise RuntimeError("No active session")
-
-        op_id = await components.executor.submit(
-            op.RunAgentOperation(
-                session_id=session_id,
-                input=UserInputPayload(text=input_content),
-            )
-        )
-        await components.executor.wait_for(op_id)
-        await components.event_queue.join()
-    except KeyboardInterrupt:
-        await handle_keyboard_interrupt(components.executor)
-    finally:
-        await cleanup_app_components(components)

klaude_code/cli/main.py

@@ -13,44 +13,6 @@ from klaude_code.session import Session
 from klaude_code.tui.command.resume_cmd import select_session_sync
 from klaude_code.ui.terminal.title import update_terminal_title
 
-
-def read_input_content(cli_argument: str) -> str | None:
-    """Read and merge input from stdin and CLI argument.
-
-    Args:
-        cli_argument: The input content passed as CLI argument.
-
-    Returns:
-        The merged input content, or None if no input was provided.
-    """
-    from klaude_code.log import log
-
-    parts: list[str] = []
-
-    # Handle stdin input
-    if not sys.stdin.isatty():
-        try:
-            stdin = sys.stdin.read().rstrip("\n")
-            if stdin:
-                parts.append(stdin)
-        except (OSError, ValueError) as e:
-            # Expected I/O-related errors when reading from stdin (e.g. broken pipe, closed stream).
-            log((f"Error reading from stdin: {e}", "red"))
-        except Exception as e:
-            # Unexpected errors are still reported but kept from crashing the CLI.
-            log((f"Unexpected error reading from stdin: {e}", "red"))
-
-    if cli_argument:
-        parts.append(cli_argument)
-
-    content = "\n".join(parts)
-    if len(content) == 0:
-        log(("Error: No input content provided", "red"))
-        return None
-
-    return content
-
-
 ENV_HELP = """\
 Environment Variables:
 
@@ -76,101 +38,6 @@ register_cost_commands(app)
 register_self_update_commands(app)
 
 
-@app.command("exec")
-def exec_command(
-    input_content: str = typer.Argument("", help="Input message to execute"),
-    model: str | None = typer.Option(
-        None,
-        "--model",
-        "-m",
-        help="Override model config name (uses main model by default)",
-        rich_help_panel="LLM",
-    ),
-    select_model: bool = typer.Option(
-        False,
-        "--select-model",
-        "-s",
-        help="Interactively choose a model at startup",
-        rich_help_panel="LLM",
-    ),
-    debug: bool = typer.Option(
-        False,
-        "--debug",
-        "-d",
-        help="Enable debug mode",
-        rich_help_panel="Debug",
-    ),
-    debug_filter: str | None = typer.Option(
-        None,
-        "--debug-filter",
-        help=DEBUG_FILTER_HELP,
-        rich_help_panel="Debug",
-    ),
-    vanilla: bool = typer.Option(
-        False,
-        "--vanilla",
-        help="Vanilla mode exposes the model's raw API behavior: it provides only minimal tools (Bash, Read & Edit) and omits system prompts and reminders.",
-    ),
-    stream_json: bool = typer.Option(
-        False,
-        "--stream-json",
-        help="Stream all events as JSON lines to stdout.",
-    ),
-) -> None:
-    """Execute non-interactively with provided input."""
-    update_terminal_title()
-
-    merged_input = read_input_content(input_content)
-    if merged_input is None:
-        raise typer.Exit(1)
-
-    from klaude_code.app.runtime import AppInitConfig, run_exec
-    from klaude_code.config import load_config
-    from klaude_code.tui.command.model_select import select_model_interactive
-
-    chosen_model = model
-    if model or select_model:
-        chosen_model = select_model_interactive(preferred=model)
-        if chosen_model is None:
-            raise typer.Exit(1)
-    else:
-        # Check if main_model is configured; if not, trigger interactive selection
-        config = load_config()
-        if config.main_model is None:
-            chosen_model = select_model_interactive()
-            if chosen_model is None:
-                raise typer.Exit(1)
-            # Save the selection as default
-            config.main_model = chosen_model
-            from klaude_code.config.config import config_path
-            from klaude_code.log import log
-
-            asyncio.run(config.save())
-            log(f"Saved main_model={chosen_model} to {config_path}", style="cyan")
-
-    debug_enabled, debug_filters, log_path = prepare_debug_logging(debug, debug_filter)
-
-    init_config = AppInitConfig(
-        model=chosen_model,
-        debug=debug_enabled,
-        vanilla=vanilla,
-        debug_filters=debug_filters,
-        stream_json=stream_json,
-    )
-
-    if log_path:
-        from klaude_code.log import log
-
-        log(f"Debug log: {log_path}", style="dim")
-
-    asyncio.run(
-        run_exec(
-            init_config=init_config,
-            input_content=merged_input,
-        )
-    )
-
-
 @app.callback(invoke_without_command=True)
 def main_callback(
     ctx: typer.Context,
@@ -220,13 +87,23 @@ def main_callback(
     vanilla: bool = typer.Option(
         False,
         "--vanilla",
-        help="Vanilla mode exposes the model's raw API behavior: it provides only minimal tools (Bash, Read & Edit) and omits system prompts and reminders.",
+        help="Vanilla mode exposes the model's raw API behavior: it provides only minimal tools (Bash, Read, Write & Edit) and omits system prompts and reminders.",
+    ),
+    banana: bool = typer.Option(
+        False,
+        "--banana",
+        help="Image generation mode with Nano Banana",
+        rich_help_panel="LLM",
     ),
 ) -> None:
     # Only run interactive mode when no subcommand is invoked
     if ctx.invoked_subcommand is None:
         from klaude_code.log import log
 
+        if vanilla and banana:
+            log(("Error: --banana cannot be combined with --vanilla", "red"))
+            raise typer.Exit(2)
+
         resume_by_id_value = resume_by_id.strip() if resume_by_id is not None else None
         if resume_by_id_value == "":
             log(("Error: --resume-by-id cannot be empty", "red"))
@@ -241,24 +118,10 @@ def main_callback(
             log(("Hint: run `klaude --resume` to select an existing session", "yellow"))
             raise typer.Exit(2)
 
-        # In non-interactive environments, default to exec-mode behavior.
-        # This allows: echo "…" | klaude
         if not sys.stdin.isatty() or not sys.stdout.isatty():
-            if continue_ or resume or resume_by_id is not None:
-                log(("Error: --continue/--resume options require a TTY", "red"))
-                log(("Hint: use `klaude exec` for non-interactive usage", "yellow"))
-                raise typer.Exit(2)
-
-            exec_command(
-                input_content="",
-                model=model,
-                select_model=select_model,
-                debug=debug,
-                debug_filter=debug_filter,
-                vanilla=vanilla,
-                stream_json=False,
-            )
-            return
+            log(("Error: interactive mode requires a TTY", "red"))
+            log(("Hint: run klaude from an interactive terminal", "yellow"))
+            raise typer.Exit(2)
 
         from klaude_code.app.runtime import AppInitConfig
         from klaude_code.tui.command.model_select import select_model_interactive
@@ -267,7 +130,10 @@ def main_callback(
         update_terminal_title()
 
         chosen_model = model
-        if model or select_model:
+        if banana:
+            # Banana mode always uses the built-in Nano Banana Pro image model.
+            chosen_model = "nano-banana-pro@or"
+        elif model or select_model:
             chosen_model = select_model_interactive(preferred=model)
             if chosen_model is None:
                 return
@@ -340,6 +206,7 @@ def main_callback(
             model=chosen_model,
             debug=debug_enabled,
             vanilla=vanilla,
+            banana=banana,
             debug_filters=debug_filters,
         )
 

klaude_code/config/assets/builtin_config.yaml

@@ -250,6 +250,18 @@ provider_list:
         input: 0.5
         output: 3.0
         cache_read: 0.05
+  - model_name: nano-banana-pro@google
+    model_params:
+      model: gemini-3-pro-image-preview
+      context_limit: 1048576
+      modalities:
+      - image
+      - text
+      cost:
+        input: 2
+        output: 12
+        cache_read: 0.2
+        image: 120
 
 - provider_name: bedrock
   protocol: bedrock
@@ -266,6 +278,7 @@ provider_list:
         output: 15.0
         cache_read: 0.3
         cache_write: 3.75
+
 - provider_name: deepseek
   protocol: anthropic
   api_key: ${DEEPSEEK_API_KEY}

klaude_code/const.py

@@ -155,7 +155,7 @@ MARKDOWN_RIGHT_MARGIN = 2  # Right margin (columns) for markdown rendering
 STATUS_HINT_TEXT = " (esc to interrupt)"  # Status hint text shown after spinner
 
 # Spinner status texts
-STATUS_WAITING_TEXT = "Awaiting …"
+STATUS_WAITING_TEXT = "Connecting …"
 STATUS_THINKING_TEXT = "Reasoning …"
 STATUS_COMPOSING_TEXT = "Generating"
 

klaude_code/core/agent_profile.py

@@ -58,6 +58,9 @@ PROMPT_FILES: dict[str, str] = {
 }
 
 
+NANO_BANANA_SYSTEM_PROMPT_PATH = "prompts/prompt-nano-banana.md"
+
+
 STRUCTURED_OUTPUT_PROMPT = """\
 
 # Structured Output
@@ -289,3 +292,28 @@ class VanillaModelProfileProvider(ModelProfileProvider):
         if output_schema:
             return with_structured_output(profile, output_schema)
         return profile
+
+
+class NanoBananaModelProfileProvider(ModelProfileProvider):
+    """Provider for the Nano Banana image generation model.
+
+    This mode uses a dedicated system prompt and strips all tools/reminders.
+    """
+
+    def build_profile(
+        self,
+        llm_client: LLMClientABC,
+        sub_agent_type: tools.SubAgentType | None = None,
+        *,
+        output_schema: dict[str, Any] | None = None,
+    ) -> AgentProfile:
+        del sub_agent_type
+        profile = AgentProfile(
+            llm_client=llm_client,
+            system_prompt=_load_prompt_by_path(NANO_BANANA_SYSTEM_PROMPT_PATH),
+            tools=[],
+            reminders=[],
+        )
+        if output_schema:
+            return with_structured_output(profile, output_schema)
+        return profile

klaude_code/core/manager/llm_clients_builder.py

@@ -21,7 +21,7 @@ def build_llm_clients(
     # Resolve main agent LLM config
     model_name = model_override or config.main_model
     if model_name is None:
-        raise ValueError("No model specified. Use --model or --select-model to specify a model.")
+        raise ValueError("No model specified. Set main_model in the config or pass --model.")
     llm_config = config.get_model_config(model_name)
 
     log_debug(

klaude_code/core/prompts/prompt-nano-banana.md

@@ -0,0 +1 @@
+You're a helpful art assistant

klaude_code/core/tool/shell/command_safety.py

@@ -1,5 +1,4 @@
 import os
-import re
 import shlex
 
 
@@ -11,76 +10,6 @@ class SafetyCheckResult:
         self.error_msg = error_msg
 
 
-def _is_valid_sed_n_arg(s: str | None) -> bool:
-    if not s:
-        return False
-    # Matches: Np or M,Np where M,N are positive integers
-    return bool(re.fullmatch(r"\d+(,\d+)?p", s))
-
-
-def _is_safe_awk_program(program: str) -> SafetyCheckResult:
-    lowered = program.lower()
-
-    if "`" in program:
-        return SafetyCheckResult(False, "awk: backticks not allowed in program")
-    if "$(" in program:
-        return SafetyCheckResult(False, "awk: command substitution not allowed in program")
-    if "|&" in program:
-        return SafetyCheckResult(False, "awk: background pipeline not allowed in program")
-
-    if "system(" in lowered:
-        return SafetyCheckResult(False, "awk: system() call not allowed in program")
-
-    if re.search(r"(?<![|&>])\bprint\s*\|", program, re.IGNORECASE):
-        return SafetyCheckResult(False, "awk: piping output to external command not allowed")
-    if re.search(r"\bprintf\s*\|", program, re.IGNORECASE):
-        return SafetyCheckResult(False, "awk: piping output to external command not allowed")
-
-    return SafetyCheckResult(True)
-
-
-def _is_safe_awk_argv(argv: list[str]) -> SafetyCheckResult:
-    if len(argv) < 2:
-        return SafetyCheckResult(False, "awk: Missing program")
-
-    program: str | None = None
-
-    i = 1
-    while i < len(argv):
-        arg = argv[i]
-
-        if arg in {"-f", "--file", "--source"} or arg.startswith("-f"):
-            return SafetyCheckResult(False, "awk: -f/--file not allowed")
-
-        if arg in {"-e", "--exec"}:
-            if i + 1 >= len(argv):
-                return SafetyCheckResult(False, "awk: Missing program for -e")
-            script = argv[i + 1]
-            program_check = _is_safe_awk_program(script)
-            if not program_check.is_safe:
-                return program_check
-            if program is None:
-                program = script
-            i += 2
-            continue
-
-        if arg.startswith("-"):
-            i += 1
-            continue
-
-        if program is None:
-            program_check = _is_safe_awk_program(arg)
-            if not program_check.is_safe:
-                return program_check
-            program = arg
-        i += 1
-
-    if program is None:
-        return SafetyCheckResult(False, "awk: Missing program")
-
-    return SafetyCheckResult(True)
-
-
 def _is_safe_rm_argv(argv: list[str]) -> SafetyCheckResult:
     """Check safety of rm command arguments."""
     # Enforce strict safety rules for rm operands
@@ -217,112 +146,12 @@ def _is_safe_argv(argv: list[str]) -> SafetyCheckResult:
 
     cmd0 = argv[0]
 
-    # if _has_shell_redirection(argv):
-    #     return SafetyCheckResult(False, "Shell redirection and pipelines are not allowed in single commands")
-
-    # Special handling for rm to prevent dangerous operations
     if cmd0 == "rm":
         return _is_safe_rm_argv(argv)
 
-    # Special handling for trash to prevent dangerous operations
     if cmd0 == "trash":
         return _is_safe_trash_argv(argv)
 
-    if cmd0 == "find":
-        unsafe_opts = {
-            "-exec": "command execution",
-            "-execdir": "command execution",
-            "-ok": "interactive command execution",
-            "-okdir": "interactive command execution",
-            "-delete": "file deletion",
-            "-fls": "file output",
-            "-fprint": "file output",
-            "-fprint0": "file output",
-            "-fprintf": "formatted file output",
-        }
-        for arg in argv[1:]:
-            if arg in unsafe_opts:
-                return SafetyCheckResult(False, f"find: {unsafe_opts[arg]} option '{arg}' not allowed")
-        return SafetyCheckResult(True)
-
-    if cmd0 == "git":
-        sub = argv[1] if len(argv) > 1 else None
-        if not sub:
-            return SafetyCheckResult(False, "git: Missing subcommand")
-
-        # Allow most local git operations, but block remote operations
-        allowed_git_cmds = {
-            "add",
-            "branch",
-            "checkout",
-            "commit",
-            "config",
-            "diff",
-            "fetch",
-            "init",
-            "log",
-            "merge",
-            "mv",
-            "rebase",
-            "reset",
-            "restore",
-            "revert",
-            "rm",
-            "show",
-            "stash",
-            "status",
-            "switch",
-            "tag",
-            "clone",
-            "worktree",
-            "push",
-            "pull",
-            "remote",
-        }
-        if sub not in allowed_git_cmds:
-            return SafetyCheckResult(False, f"git: Subcommand '{sub}' not in allow list")
-        return SafetyCheckResult(True)
-
-    # Build tools and linters - allow all subcommands
-    if cmd0 in {
-        "cargo",
-        "uv",
-        "go",
-        "ruff",
-        "pyright",
-        "make",
-        "npm",
-        "pnpm",
-        "bun",
-    }:
-        return SafetyCheckResult(True)
-
-    if cmd0 == "sed":
-        # Allow sed -n patterns (line printing)
-        if len(argv) >= 3 and argv[1] == "-n" and _is_valid_sed_n_arg(argv[2]):
-            return SafetyCheckResult(True)
-        # Allow simple text replacement: sed 's/old/new/g' file
-        # or sed -i 's/old/new/g' file for in-place editing
-        if len(argv) >= 3:
-            # Find the sed script argument (usually starts with 's/')
-            for arg in argv[1:]:
-                if arg.startswith("s/") or arg.startswith("s|"):
-                    # Basic safety check: no command execution in replacement
-                    if ";" in arg:
-                        return SafetyCheckResult(False, f"sed: Command separator ';' not allowed in '{arg}'")
-                    if "`" in arg:
-                        return SafetyCheckResult(False, f"sed: Backticks not allowed in '{arg}'")
-                    if "$(" in arg:
-                        return SafetyCheckResult(False, f"sed: Command substitution not allowed in '{arg}'")
-                    return SafetyCheckResult(True)
-        return SafetyCheckResult(
-            False,
-            "sed: Only text replacement (s/old/new/) or line printing (-n 'Np') is allowed",
-        )
-
-    if cmd0 == "awk":
-        return _is_safe_awk_argv(argv)
-
     # Default allow when command is not explicitly restricted
     return SafetyCheckResult(True)
 
@@ -330,30 +159,16 @@ def _is_safe_argv(argv: list[str]) -> SafetyCheckResult:
 def is_safe_command(command: str) -> SafetyCheckResult:
     """Determine if a command is safe enough to run.
 
-    The check is intentionally lightweight: it blocks only a small set of
-    obviously dangerous patterns (rm/trash/git remotes, unsafe sed/awk,
-    find -exec/-delete, etc.) and otherwise lets the real shell surface
-    syntax errors (for example, unmatched quotes in complex multiline
-    scripts).
+    Only rm and trash commands are checked for safety. All other commands
+    are allowed by default.
     """
-
-    # Try to parse into an argv-style list first. If this fails (e.g. due
-    # to unterminated quotes in a complex heredoc), treat the command as
-    # safe here and let bash itself perform syntax checking instead of
-    # blocking execution pre-emptively.
     try:
         argv = shlex.split(command, posix=True)
     except ValueError:
-        # If we cannot reliably parse the command (e.g. due to unterminated
-        # quotes in a complex heredoc), treat it as safe here and let the
-        # real shell surface any syntax errors instead of blocking execution
-        # pre-emptively.
+        # If we cannot reliably parse the command, treat it as safe here
+        # and let the real shell surface any syntax errors
         return SafetyCheckResult(True)
 
-    # All further safety checks are done directly on the parsed argv via
-    # _is_safe_argv. We intentionally avoid trying to re-interpret complex
-    # shell sequences here and rely on the real shell to handle syntax.
-
     if not argv:
         return SafetyCheckResult(False, "Empty command")
 

klaude_code/core/turn.py

@@ -348,7 +348,7 @@ class TurnExecutor:
                         style="red",
                         debug_type=DebugType.RESPONSE,
                     )
-                case message.ToolCallStartItem() as msg:
+                case message.ToolCallStartDelta() as msg:
                     if thinking_active:
                         thinking_active = False
                         yield events.ThinkingEndEvent(

klaude_code/llm/anthropic/client.py

@@ -169,7 +169,7 @@ async def parse_anthropic_stream(
                 match event.content_block:
                     case BetaToolUseBlock() as block:
                         metadata_tracker.record_token()
-                        yield message.ToolCallStartItem(
+                        yield message.ToolCallStartDelta(
                             response_id=response_id,
                             call_id=block.id,
                             name=block.name,

klaude_code/llm/google/client.py

@@ -242,7 +242,7 @@ async def parse_google_stream(
 
             if call_id not in started_tool_items:
                 started_tool_items.add(call_id)
-                yield message.ToolCallStartItem(response_id=response_id, call_id=call_id, name=name)
+                yield message.ToolCallStartDelta(response_id=response_id, call_id=call_id, name=name)
 
             args_obj = getattr(function_call, "args", None)
             if args_obj is not None: