bub 0.4.1__tar.gz → 0.4.3__tar.gz

{bub-0.4.1 → bub-0.4.3}/PKG-INFO

@@ -1,11 +1,12 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: bub
-Version: 0.4.1
+Version: 0.4.3
 Summary: A common shape for agents that live alongside people.
 Project-URL: Homepage, https://bub.build
 Project-URL: Repository, https://github.com/bubbuild/bub
 Project-URL: Documentation, https://bub.build
 Author-email: Chojan Shang <psiace@apache.org>, Frost Ming <me@frostming.com>, Yihong <zouzou0208@gmail.com>
+License: Apache-2.0
 License-File: LICENSE
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python
@@ -153,7 +154,8 @@ Lines starting with `,` enter internal command mode (`,help`, `,skill name=my-sk
 | `BUB_API_KEY`               | —                            | Provider key (optional with `bub login openai`)      |
 | `BUB_API_BASE`              | —                            | Custom provider endpoint                             |
 | `BUB_CLIENT_ARGS`           | —                            | JSON object forwarded to the underlying model client |
-| `BUB_MAX_STEPS`             | `50`                         | Max tool-use loop iterations                         |
+| `BUB_COMPLETION_ARGS`       | —                            | JSON object forwarded to each completion call         |
+| `BUB_MAX_STEPS`             | unlimited                    | Tool-use loop limit; must be a positive integer      |
 | `BUB_MAX_TOKENS`            | `16384`                      | Max tokens per model call                            |
 | `BUB_MODEL_TIMEOUT_SECONDS` | —                            | Model call timeout (seconds)                         |
 

{bub-0.4.1 → bub-0.4.3}/README.md

@@ -116,7 +116,8 @@ Lines starting with `,` enter internal command mode (`,help`, `,skill name=my-sk
 | `BUB_API_KEY`               | —                            | Provider key (optional with `bub login openai`)      |
 | `BUB_API_BASE`              | —                            | Custom provider endpoint                             |
 | `BUB_CLIENT_ARGS`           | —                            | JSON object forwarded to the underlying model client |
-| `BUB_MAX_STEPS`             | `50`                         | Max tool-use loop iterations                         |
+| `BUB_COMPLETION_ARGS`       | —                            | JSON object forwarded to each completion call         |
+| `BUB_MAX_STEPS`             | unlimited                    | Tool-use loop limit; must be a positive integer      |
 | `BUB_MAX_TOKENS`            | `16384`                      | Max tokens per model call                            |
 | `BUB_MODEL_TIMEOUT_SECONDS` | —                            | Model call timeout (seconds)                         |
 

{bub-0.4.1 → bub-0.4.3}/pyproject.toml

@@ -9,6 +9,7 @@ authors = [
 ]
 readme = "README.md"
 requires-python = ">=3.12,<4.0"
+license = { text = "Apache-2.0" }
 classifiers = [
     "Intended Audience :: Developers",
     "Programming Language :: Python",

{bub-0.4.1 → bub-0.4.3}/src/bub/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.4.1'
-__version_tuple__ = version_tuple = (0, 4, 1)
+__version__ = version = '0.4.3'
+__version_tuple__ = version_tuple = (0, 4, 3)
 
 __commit_id__ = commit_id = None

{bub-0.4.1 → bub-0.4.3}/src/bub/builtin/agent.py

@@ -22,21 +22,21 @@ from bub.builtin.model_runner import (
     is_context_length_error,
 )
 from bub.builtin.settings import load_settings
-from bub.builtin.tape import Tape
 from bub.envelope import field_of
 from bub.framework import BubFramework
 from bub.skills import discover_skills, render_skills_prompt
+from bub.store import AsyncTapeStoreAdapter, InMemoryTapeStore, is_async_tape_store
 from bub.streaming import AsyncStreamEvents, StreamEvent, StreamState
-from bub.tape import AsyncTapeStoreAdapter, InMemoryTapeStore, is_async_tape_store
+from bub.tape import Tape
 from bub.tools import (
     REGISTRY,
     Tool,
     ToolContext,
+    model_tools,
 )
 from bub.turn import TurnState
 from bub.utils import workspace_from_state
 
-CONTINUE_PROMPT = "Continue the task until all targets are completed."
 HINT_RE = re.compile(r"\$([A-Za-z0-9_.-]+)")
 MAX_AUTO_HANDOFF_RETRIES = 1
 
@@ -290,7 +290,7 @@ class Agent:
                 )
                 return
 
-            next_prompt = self._continue_prompt(tape)
+            next_prompt = await self.framework.continue_prompt(prompt=next_prompt, tape=tape, state=state)
             await tape.append_event(
                 "loop.step",
                 {
@@ -352,8 +352,6 @@ class Agent:
         allowed_skills: set[str] | None,
         tools: list[Tool],
     ) -> AsyncStreamEvents:
-        from bub.builtin.tools import model_tools
-
         system_prompt = self._system_prompt(
             prompt_text, state=tape.context.state, allowed_skills=allowed_skills, tools=tools
         )
@@ -399,11 +397,6 @@ class Agent:
             blocks.append(skills_prompt)
         return "\n\n".join(blocks)
 
-    def _continue_prompt(self, tape: Tape) -> str:
-        if "context" in tape.context.state:
-            return f"{CONTINUE_PROMPT} [context: {tape.context.state['context']}]"
-        return CONTINUE_PROMPT
-
     def _has_steering_messages(self, state: TurnState) -> bool:
         steering_inbox = self.framework.get_steering_inbox()
         return bool(steering_inbox and steering_inbox.message_count(state) > 0)

{bub-0.4.1 → bub-0.4.3}/src/bub/builtin/cli.py

@@ -87,6 +87,13 @@ def gateway(
     framework = ctx.ensure_object(BubFramework)
 
     manager = ChannelManager(framework, enabled_channels=enable_channels or None)
+    if not manager.enabled_channels():
+        typer.secho(
+            "No channels are enabled. Configure at least one channel with 'bub onboard' or '--enable-channel'.",
+            err=True,
+            fg="red",
+        )
+        raise typer.Exit(1)
     asyncio.run(manager.listen_and_run())
 
 

{bub-0.4.1 → bub-0.4.3}/src/bub/builtin/hook_impl.py

@@ -1,5 +1,6 @@
 import sys
 from datetime import datetime
+from difflib import get_close_matches
 from pathlib import Path
 from typing import cast
 
@@ -18,9 +19,11 @@ from bub.channels.message import ChannelMessage, MediaItem
 from bub.envelope import Envelope, content_of, field_of
 from bub.framework import BubFramework
 from bub.hooks import hookimpl
+from bub.hooks.interception import ToolCall, ToolCallDecision
 from bub.model_selection import ModelChoice, ModelOptions
-from bub.streaming import AsyncStreamEvents
-from bub.tape import TapeContext, TapeStore
+from bub.store import TapeStore
+from bub.streaming import AsyncStreamEvents, StreamState
+from bub.tape import Tape, TapeContext
 from bub.turn import TurnState
 
 AGENTS_FILE_NAME = "AGENTS.md"
@@ -57,6 +60,7 @@ When responding to a channel message, you MUST:
 Excessively long context may cause model call failures. In this case, you MAY use tape.info to retrieve the token usage and you SHOULD use tape.handoff tool to shorten the retrieved history.
 </context_contract>
 """
+DEFAULT_CONTINUE_PROMPT = "Continue the task until all targets are completed."
 
 
 class BuiltinImpl:
@@ -90,6 +94,16 @@ class BuiltinImpl:
                 return str(model) if model else None
         return None
 
+    async def _recover_session_reasoning_effort(self, session_id: str) -> str | None:
+        """Recover the latest per-session reasoning effort override."""
+        session = self._get_agent().tape.session_tape(session_id, self.framework.workspace)
+        entries = list(await session.store.fetch_all(session.query().kinds("event")))
+        for entry in reversed(entries):
+            if entry.kind == "event" and entry.payload.get("name") == "reasoning_effort_switch":
+                reasoning_effort = (entry.payload.get("data") or {}).get("reasoning_effort")
+                return str(reasoning_effort) if reasoning_effort else None
+        return None
+
     @staticmethod
     async def _discard_message(_: ChannelMessage) -> None:
         return
@@ -149,6 +163,8 @@ class BuiltinImpl:
         # fresh/unknown session never inherits another session's model.
         if model := await self._recover_session_model(session_id):
             state["model"] = model
+        if reasoning_effort := await self._recover_session_reasoning_effort(session_id):
+            state["reasoning_effort"] = reasoning_effort
         if model := field_of(message, "context", {}).get("model"):
             state["model"] = model
         if thread_id := field_of(message, "context", {}).get("thread_id"):
@@ -161,9 +177,8 @@ class BuiltinImpl:
         lifespan = field_of(message, "lifespan")
         if lifespan is not None:
             await lifespan.__aexit__(tp, value, traceback)
-        # The per-session model override is persisted on the session tape by the
-        # ``model`` tool itself (a ``model_switch`` event, merged back at end of
-        # turn), so nothing to write here — this hook only closes the lifespan.
+        # Per-session completion overrides are persisted by their tools as tape
+        # events, so nothing to write here — this hook only closes the lifespan.
 
     @hookimpl
     async def build_prompt(self, message: ChannelMessage, session_id: str, state: TurnState) -> str | list[dict]:
@@ -203,6 +218,13 @@ class BuiltinImpl:
             model=state.get("model"),
         )
 
+    @hookimpl
+    def continue_prompt(self, prompt: str | list[dict], tape: Tape, state: StreamState) -> str:
+        del prompt, state
+        if "context" in tape.context.state:
+            return f"{DEFAULT_CONTINUE_PROMPT} [context: {tape.context.state['context']}]"
+        return DEFAULT_CONTINUE_PROMPT
+
     @hookimpl
     def register_cli_commands(self, app: typer.Typer) -> None:
         from bub.builtin import cli
@@ -248,7 +270,6 @@ class BuiltinImpl:
             "Channels",
             choices=available_channels,
             enabled=default_channels,
-            validate=lambda values: True if values else "Select at least one channel.",
         )
 
         stream_output = bub_inquirer.ask_confirm("Stream output", default=bool(current_config.get("stream_output")))
@@ -345,7 +366,7 @@ class BuiltinImpl:
     @hookimpl
     def provide_tape_store(self) -> TapeStore:
         import bub
-        from bub.builtin.store import FileTapeStore
+        from bub.store import FileTapeStore
 
         return FileTapeStore(directory=bub.home / "tapes")
 
@@ -368,3 +389,31 @@ class BuiltinImpl:
         if channel_router is None:
             return None
         return await channel_router.admit_channel_message(session_id=session_id, message=message, turn=turn)
+
+    @hookimpl
+    async def before_tool_call(
+        self,
+        call: ToolCall,
+        state: TurnState,
+    ) -> ToolCallDecision | None:
+        """Recover hallucinated/unknown tool names without interrupting the turn.
+
+        When the model invokes a tool outside the current model-facing tool set,
+        replace it with a guidance ``tool_result`` so the model can re-issue a
+        valid call on the next step.
+        """
+        from bub.tools import REGISTRY, model_tools
+
+        available_tools = tuple(tool_item.name for tool_item in model_tools(REGISTRY.values()))
+        if call.tool in available_tools:
+            return None
+
+        matches = get_close_matches(call.tool, available_tools, n=3, cutoff=0.6)
+        if matches:
+            suggestions = "\n".join(f"- {name}" for name in matches)
+            guidance = f"Tool `{call.tool}` does not exist. Did you mean one of the following?\n{suggestions}"
+        elif "skill" in available_tools:
+            guidance = f"Tool `{call.tool}` does not exist. Invoke the `skill` tool to list available skills."
+        else:
+            guidance = f"Tool `{call.tool}` does not exist. No similar tool is available."
+        return ToolCallDecision.replace(guidance)

{bub-0.4.1 → bub-0.4.3}/src/bub/builtin/model_runner.py

@@ -28,7 +28,6 @@ from pydantic import TypeAdapter, ValidationError
 
 from bub.builtin.codex_provider import OpenaiCodexProvider, should_use_openai_codex_provider
 from bub.builtin.settings import AgentSettings, ModelCandidate
-from bub.builtin.tape import Tape
 from bub.errors import BubError, ErrorKind
 from bub.hooks.interception import (
     AgentHooks,
@@ -37,6 +36,7 @@ from bub.hooks.interception import (
     LlmCallResult,
 )
 from bub.streaming import AsyncStreamEvents, StreamEvent, StreamState
+from bub.tape import Tape
 from bub.tools import Tool, ToolContext, ToolExecutor
 
 CONTEXT_LENGTH_PATTERNS = re.compile(
@@ -81,25 +81,33 @@ class ModelRunner:
         return AnyLLM.create(candidate.provider, **client_kwargs)
 
     async def completion_response(
-        self, *, model: str, messages: list[dict[str, Any]], tools: list[Tool], max_tokens: int | None = None
+        self,
+        *,
+        model: str,
+        messages: list[dict[str, Any]],
+        tools: list[Tool],
+        max_tokens: int | None = None,
+        reasoning_effort: str | None = None,
     ) -> CompletionResult:
-        from bub.builtin.tools import completion_tools
-
-        tool_payloads = completion_tools(tools) or None
+        tool_payloads = [tool.to_schema() for tool in tools] or None
         completion_messages: list[dict[str, Any] | ChatCompletionMessage] = list(messages)
         clients = list(self.iter_llm_clients(model))
         completion_error: Exception | None = None
         for index, (candidate, llm) in enumerate(clients):
             try:
                 streaming = llm.SUPPORTS_COMPLETION_STREAMING
-                return await llm.acompletion(
-                    model=candidate.model_id,
-                    messages=completion_messages,
-                    tools=tool_payloads,
-                    max_tokens=max_tokens if max_tokens is not None else self.settings.max_tokens,
-                    stream=streaming,
+                completion_kwargs = {
+                    **self.settings.completion_args,
                     **_extra_options(llm, stream=streaming),
-                )
+                    "model": candidate.model_id,
+                    "messages": completion_messages,
+                    "tools": tool_payloads,
+                    "max_tokens": max_tokens if max_tokens is not None else self.settings.max_tokens,
+                    "stream": streaming,
+                }
+                if reasoning_effort is not None:
+                    completion_kwargs["reasoning_effort"] = reasoning_effort
+                return cast("CompletionResult", await llm.acompletion(**completion_kwargs))
             except Exception as exc:
                 if completion_error is None:
                     completion_error = exc
@@ -173,6 +181,7 @@ class ModelRunner:
                         messages=list(request.messages),
                         tools=tools,
                         max_tokens=request.max_tokens,
+                        reasoning_effort=tape.context.state.get("reasoning_effort"),
                     )
                     async for event in self._completion_events(completion, state, output):
                         yield event
@@ -452,10 +461,23 @@ def tool_invocation_from_native(
     tool_call: ChatCompletionMessageToolCall,
     tool_map: dict[str, Tool],
 ) -> tuple[Tool, dict[str, Any]]:
+    """Resolve a model tool call to (runtime tool, arguments).
+
+    An unknown tool name is not treated as a fatal error: it is surfaced as a
+    placeholder ``Tool`` so the invocation flows through ``ToolExecutor`` and
+    builtin hooks (e.g. ``before_tool_call``) can recover it into a guidance
+    ``tool_result`` instead of interrupting the turn. If no hook replaces the
+    call, the placeholder raises a clear tool error rather than succeeding with
+    an empty result.
+    """
     tool_name, arguments = parse_native_function_call(tool_call)
     tool_obj = tool_map.get(tool_name)
     if tool_obj is None:
-        raise BubError(ErrorKind.TOOL, f"Unknown tool name: {tool_name}.")
+
+        def raise_unknown_tool(**_: Any) -> None:
+            raise BubError(ErrorKind.TOOL, f"Unknown tool name: {tool_name}.")
+
+        return Tool(name=tool_name, handler=raise_unknown_tool), arguments
     return tool_obj, arguments
 
 

{bub-0.4.1 → bub-0.4.3}/src/bub/builtin/settings.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 import pathlib
 import re
+import sys
 from dataclasses import dataclass
 from typing import Any
 
@@ -56,10 +57,11 @@ class AgentSettings(Settings):
     fallback_models: list[str] | None = None
     api_key: str | dict[str, str] | None = None
     api_base: str | dict[str, str] | None = None
-    max_steps: int = 50
+    max_steps: int = Field(default=sys.maxsize, gt=0)
     max_tokens: int = DEFAULT_MAX_TOKENS
     model_timeout_seconds: int | None = None
     client_args: dict[str, Any] = Field(default_factory=dict)
+    completion_args: dict[str, Any] = Field(default_factory=dict)
     verbose: int = Field(default=0, description="Verbosity level for logging. Higher means more verbose.", ge=0, le=2)
 
     @classmethod
@@ -79,9 +81,9 @@ class AgentSettings(Settings):
             file_secret_settings,
         )
 
-    @field_validator("client_args", mode="before")
+    @field_validator("client_args", "completion_args", mode="before")
     @classmethod
-    def default_client_args(cls, value: Any) -> Any:
+    def default_dict_args(cls, value: Any) -> Any:
         return {} if value is None else value
 
     def model_candidates(self, model: str) -> list[ModelCandidate]:

{bub-0.4.1 → bub-0.4.3}/src/bub/builtin/tools.py

@@ -4,11 +4,9 @@ import asyncio
 import json
 import uuid
 from collections.abc import Iterable
-from dataclasses import replace
 from pathlib import Path
 from typing import TYPE_CHECKING, cast
 
-from openai.types.chat import ChatCompletionToolParam
 from pydantic import BaseModel, Field
 
 from bub.builtin.shell_manager import shell_manager
@@ -72,11 +70,6 @@ def resolve_tool_names(names: Iterable[str] | None = None, *, exclude: Iterable[
     return resolved - excluded
 
 
-def model_tools(tools: Iterable[Tool]) -> list[Tool]:
-    """Convert runtime tool names into model-safe aliases."""
-    return [replace(tool_item, name=_to_model_name(tool_item.name)) for tool_item in tools]
-
-
 def _tool_signature(tool_item: Tool) -> str:
     properties = tool_item.parameters.get("properties", {})
     if not isinstance(properties, dict) or not properties:
@@ -90,10 +83,11 @@ def _tool_signature(tool_item: Tool) -> str:
 
 def render_tools_prompt(tools: Iterable[Tool]) -> str:
     """Render a human-readable description of tools for builtin agent prompts."""
-    if not tools:
+    agent_tools = [tool_item for tool_item in tools if tool_item.agent_use]
+    if not agent_tools:
         return ""
     lines = []
-    for tool_item in tools:
+    for tool_item in agent_tools:
         line = f"- {_tool_signature(tool_item)}"
         if tool_item.description:
             line += f": {tool_item.description}"
@@ -101,21 +95,6 @@ def render_tools_prompt(tools: Iterable[Tool]) -> str:
     return f"<available_tools>\n{'\n'.join(lines)}\n</available_tools>"
 
 
-def completion_tools(tools: Iterable[Tool]) -> list[ChatCompletionToolParam]:
-    """Build any-llm completion tool payloads from Bub tools."""
-    return [
-        {
-            "type": "function",
-            "function": {
-                "name": tool_item.name,
-                "description": tool_item.description,
-                "parameters": tool_item.parameters,
-            },
-        }
-        for tool_item in tools
-    ]
-
-
 def _raise_for_failed_shell(returncode: int | None, output: str) -> None:
     if returncode in (None, 0):
         return
@@ -376,7 +355,7 @@ async def run_subagent(param: SubAgentInput, *, context: ToolContext) -> str:
     return output
 
 
-@tool(name="help")
+@tool(name="help", agent_use=False)
 def show_help() -> str:
     """Show a help message."""
     return (
@@ -399,7 +378,7 @@ def show_help() -> str:
     )
 
 
-@tool(name="quit", context=True)
+@tool(name="quit", context=True, agent_use=False)
 async def quit_tool(*, context: ToolContext) -> str:
     """Abort the tasks of the current session. DO NOT use it in a normal workflow."""
     agent = _get_agent(context)
@@ -409,7 +388,7 @@ async def quit_tool(*, context: ToolContext) -> str:
     return "Session tasks stopped."
 
 
-@tool(name="model", context=True)
+@tool(name="model", context=True, agent_use=False)
 async def set_model(model_id: str, *, context: ToolContext) -> str:
     """Switch the model for THIS session. Invoke as the `,model <model_id>` command.
 
@@ -425,6 +404,17 @@ async def set_model(model_id: str, *, context: ToolContext) -> str:
     return f"Session model set to {model_id} (applies from the next turn)."
 
 
+@tool(name="reasoning_effort", context=True, agent_use=False)
+async def set_reasoning_effort(reasoning_effort: str, *, context: ToolContext) -> str:
+    """Set the reasoning effort for this session starting from the next turn."""
+    reasoning_effort = reasoning_effort.strip()
+    if not reasoning_effort:
+        raise ValueError("reasoning_effort must not be empty")
+    context.state["reasoning_effort"] = reasoning_effort
+    await context.tape.append_event("reasoning_effort_switch", {"reasoning_effort": reasoning_effort})
+    return f"Session reasoning effort set to {reasoning_effort} (applies from the next turn)."
+
+
 def _resolve_path(context: ToolContext, raw_path: str) -> Path:
     workspace = context.state.get("_runtime_workspace")
     path = Path(raw_path).expanduser()

{bub-0.4.1 → bub-0.4.3}/src/bub/channels/cli/__init__.py

@@ -25,7 +25,6 @@ from rich.tree import Tree
 
 import bub
 from bub.builtin.agent import Agent
-from bub.builtin.tape import TapeInfo
 from bub.channels.admission import AdmitDecision, TurnSnapshot
 from bub.channels.base import Interface
 from bub.channels.cli.ansi_bridge import render_to_ansi
@@ -39,6 +38,7 @@ from bub.channels.contracts import MessageHandler
 from bub.channels.message import ChannelMessage
 from bub.envelope import Envelope, field_of
 from bub.streaming import StreamEvent
+from bub.tape import TapeInfo
 from bub.tools import REGISTRY, tool_call_reporter
 
 _GENERATION_SPINNER: str = SPINNERS["dots"]["frames"]  # type: ignore[assignment]
@@ -54,10 +54,12 @@ class _StreamPrinter:
         expand_thinking: bool,
         presenter: TerminalPresenter,
         writer: MarkdownWriter | None = None,
+        print_end: Callable[[], None] | None = None,
         invalidate: Callable[[], None] | None = None,
     ) -> None:
         self._console = console
         self._print_head = print_head
+        self._print_end = print_end or (lambda: None)
         self._expand_thinking = expand_thinking
         self._presenter = presenter
         self._reasoning_chars = 0
@@ -82,13 +84,10 @@ class _StreamPrinter:
 
     async def _record_reasoning(self, reasoning: str) -> None:
         if not self._expand_thinking:
-            if self._reasoning_chars == 0:
-                await self._ensure_head()
             self._reasoning_chars += len(reasoning)
             self._invalidate()
             return
 
-        await self._ensure_head()
         if not self._reasoning_streaming:
             await self._print(Text("[-] Thinking", style="dim"))
             self._reasoning_streaming = True
@@ -97,19 +96,21 @@ class _StreamPrinter:
     async def _print_content(self, content: str) -> bool:
         if not (content.strip() or self.head_printed or self._reasoning_chars or self._reasoning_streaming):
             return False
-        await self._ensure_head()
         await self._close_reasoning_stream()
         await self._flush_reasoning()
+        if content.strip() or self.head_printed:
+            await self._ensure_head()
         await self._write_text(content)
         return True
 
     async def finish(self) -> None:
         await self._close_reasoning_stream()
-        if self._reasoning_chars:
-            await self._ensure_head()
         await self._flush_reasoning()
         if self._writer.has_content():
+            await self._ensure_head()
             await self._flush_text()
+        else:
+            await self._ensure_panel_end()
 
     async def _print_stream_boundary(self) -> None:
         await self.finish()
@@ -122,6 +123,12 @@ class _StreamPrinter:
         await self._presenter.write(self._print_head)
         self.head_printed = True
 
+    async def _ensure_panel_end(self) -> None:
+        if not self.head_printed:
+            return
+        await self._presenter.write(self._print_end)
+        self.head_printed = False
+
     async def _close_reasoning_stream(self) -> None:
         if not self._reasoning_streaming:
             return
@@ -163,6 +170,8 @@ class _StreamPrinter:
         def commit() -> None:
             self._console.print(finished)
             self._writer.clear()
+            self._print_end()
+            self.head_printed = False
 
         await self._presenter.write(commit)
         self._ansi_cache = None
@@ -353,6 +362,7 @@ class CliChannel(Interface):
         printer = _StreamPrinter(
             console=console,
             print_head=lambda: self._renderer.print_head(message.kind),
+            print_end=lambda: self._renderer.print_end(message.kind),
             expand_thinking=self._expand_thinking,
             presenter=self._presenter,
             invalidate=self._invalidate_prompt,

{bub-0.4.1 → bub-0.4.3}/src/bub/channels/cli/renderer.py

@@ -10,6 +10,7 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.text import Text
 
+from bub.channels.cli.writers import PanelEnd, PanelHead
 from bub.channels.message import MessageKind
 
 MAX_TOOL_PAYLOAD_CHARS = 4000
@@ -37,20 +38,10 @@ class CliRenderer:
             return
         self.console.print(Text(text, style="bright_black"))
 
-    def command_output(self, text: str) -> None:
-        if not text.strip():
-            return
-        self.console.print(f"[cyan bold]Command >[/]\n{text}")
-
-    def assistant_output(self, text: str) -> None:
-        if not text.strip():
-            return
-        self.console.print(f"[blue bold]Assistant >[/]\n{text}")
-
     def error(self, text: str) -> None:
         if not text.strip():
             return
-        self.console.print(f"[red bold]Error >[/]\n{text}")
+        self.console.print(Panel(text, title="error", border_style="red"))
 
     def input_echo(self, prompt: str, text: str, steering: bool = False) -> None:
         if not text.strip():
@@ -62,8 +53,7 @@ class CliRenderer:
         self.console.print(Text(_format_tool_call(name, args, kwargs), style="magenta"), new_line_start=True)
 
     def tool_call_success(self, *, name: str, result: Any, elapsed_ms: float) -> None:
-        rendered = _format_tool_payload(result)
-        self._tool_result(f"completed in {elapsed_ms:.0f} ms", rendered, style="green")
+        self._tool_status(f"completed in {elapsed_ms:.0f} ms", style="green")
 
     def tool_call_error(self, *, name: str, error: BaseException, elapsed_ms: float) -> None:
         rendered = _format_tool_payload({"type": error.__class__.__name__, "message": str(error)})
@@ -71,11 +61,19 @@ class CliRenderer:
 
     def print_head(self, kind: MessageKind) -> None:
         if kind == "command":
-            self.console.print("[cyan bold]Command >[/]", new_line_start=True)
+            self.console.print(PanelHead("Command", border_style="cyan"))
         elif kind == "error":
-            self.console.print("[red bold]Error >[/]", new_line_start=True)
+            self.console.print(PanelHead("Error", border_style="red"))
         else:
-            self.console.print("[blue bold]Assistant >[/]", new_line_start=True)
+            self.console.print(PanelHead("Assistant", border_style="blue"))
+
+    def print_end(self, kind: MessageKind) -> None:
+        if kind == "command":
+            self.console.print(PanelEnd(border_style="cyan"))
+        elif kind == "error":
+            self.console.print(PanelEnd(border_style="red"))
+        else:
+            self.console.print(PanelEnd(border_style="blue"))
 
     def log(self, message: object) -> None:
         text = str(message).rstrip()
@@ -83,11 +81,13 @@ class CliRenderer:
             self.console.print(text, new_line_start=True)
 
     def _tool_result(self, label: str, rendered: str, *, style: str) -> None:
-        lines = rendered.splitlines() or [""]
-        self.console.print(Text(f"  ⎿ {label}", style=style), highlight=False)
-        for line in lines:
+        self._tool_status(label, style=style)
+        for line in rendered.splitlines() or [""]:
             self.console.print(Text(f"    {line}", style="bright_black"), highlight=False)
 
+    def _tool_status(self, label: str, *, style: str) -> None:
+        self.console.print(Text(f"  ⎿ {label}", style=style), highlight=False)
+
 
 def _format_tool_call(name: str, args: tuple[Any, ...], kwargs: dict[str, Any]) -> str:
     params = _format_tool_params(args, kwargs)