bub 0.4.0__tar.gz → 0.4.2__tar.gz

{bub-0.4.0 → bub-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bub
-Version: 0.4.0
+Version: 0.4.2
 Summary: A common shape for agents that live alongside people.
 Project-URL: Homepage, https://bub.build
 Project-URL: Repository, https://github.com/bubbuild/bub
@@ -153,6 +153,7 @@ 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_COMPLETION_ARGS`       | —                            | JSON object forwarded to each completion call         |
 | `BUB_MAX_STEPS`             | `50`                         | Max tool-use loop iterations                         |
 | `BUB_MAX_TOKENS`            | `16384`                      | Max tokens per model call                            |
 | `BUB_MODEL_TIMEOUT_SECONDS` | —                            | Model call timeout (seconds)                         |

{bub-0.4.0 → bub-0.4.2}/README.md

@@ -116,6 +116,7 @@ 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_COMPLETION_ARGS`       | —                            | JSON object forwarded to each completion call         |
 | `BUB_MAX_STEPS`             | `50`                         | Max tool-use loop iterations                         |
 | `BUB_MAX_TOKENS`            | `16384`                      | Max tokens per model call                            |
 | `BUB_MODEL_TIMEOUT_SECONDS` | —                            | Model call timeout (seconds)                         |

{bub-0.4.0 → bub-0.4.2}/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.0'
-__version_tuple__ = version_tuple = (0, 4, 0)
+__version__ = version = '0.4.2'
+__version_tuple__ = version_tuple = (0, 4, 2)
 
 __commit_id__ = commit_id = None

{bub-0.4.0 → bub-0.4.2}/src/bub/builtin/agent.py

@@ -32,6 +32,7 @@ from bub.tools import (
     REGISTRY,
     Tool,
     ToolContext,
+    model_tools,
 )
 from bub.turn import TurnState
 from bub.utils import workspace_from_state
@@ -352,8 +353,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
         )

{bub-0.4.0 → bub-0.4.2}/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.0 → bub-0.4.2}/src/bub/builtin/codex_provider.py

@@ -365,22 +365,28 @@ class CodexCompletionChunkMapper:
         })
 
 
-def _completion_usage_from_response_usage(usage: Any) -> dict[str, int]:
+def _completion_usage_from_response_usage(usage: Any) -> dict[str, Any]:
     payload = usage.model_dump(exclude_none=True) if hasattr(usage, "model_dump") else usage
     if not isinstance(payload, dict):
         payload = {
             "input_tokens": getattr(usage, "input_tokens", 0),
             "output_tokens": getattr(usage, "output_tokens", 0),
             "total_tokens": getattr(usage, "total_tokens", 0),
+            "input_tokens_details": getattr(usage, "input_tokens_details", None),
         }
     prompt_tokens = int(payload.get("input_tokens") or payload.get("prompt_tokens") or 0)
     completion_tokens = int(payload.get("output_tokens") or payload.get("completion_tokens") or 0)
     total_tokens = int(payload.get("total_tokens") or prompt_tokens + completion_tokens)
-    return {
+    completion_usage: dict[str, Any] = {
         "prompt_tokens": prompt_tokens,
         "completion_tokens": completion_tokens,
         "total_tokens": total_tokens,
     }
+    input_details = _mapping_from_value(payload.get("input_tokens_details"))
+    cached_tokens = input_details.get("cached_tokens")
+    if isinstance(cached_tokens, int) and not isinstance(cached_tokens, bool):
+        completion_usage["prompt_tokens_details"] = {"cached_tokens": cached_tokens}
+    return completion_usage
 
 
 def _string_attr(obj: Any, name: str) -> str:

{bub-0.4.0 → bub-0.4.2}/src/bub/builtin/hook_impl.py

@@ -90,6 +90,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 +159,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 +173,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]:
@@ -248,7 +259,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")))

{bub-0.4.0 → bub-0.4.2}/src/bub/builtin/model_runner.py

@@ -11,6 +11,7 @@ from typing import Any, Literal, cast
 
 from any_llm import AnyLLM
 from any_llm.constants import LLMProvider
+from any_llm.providers.anthropic.base import BaseAnthropicProvider
 from any_llm.providers.openai.base import BaseOpenAIProvider
 from any_llm.types.completion import (
     ChatCompletion,
@@ -46,17 +47,13 @@ TOOL_ARGUMENTS_ADAPTER = TypeAdapter(dict[str, Any])
 CompletionResult = ChatCompletion | ParsedChatCompletion[Any] | AsyncIterator[ChatCompletionChunk]
 
 
-def _stream_usage_options(llm: AnyLLM, *, stream: bool) -> dict[str, Any] | None:
-    """Make streaming completions report token usage.
-
-    OpenAI-style streaming responses omit the `usage` block unless the request
-    sets `stream_options.include_usage`; without it every streamed run records
-    zero tokens (and zero cost). Only OpenAI-compatible providers accept the
-    field, so gate on the provider base class — anthropic/gemini reject it.
-    """
-    if stream and isinstance(llm, BaseOpenAIProvider):
-        return {"include_usage": True}
-    return None
+def _extra_options(llm: AnyLLM, *, stream: bool) -> dict[str, Any]:
+    """Return provider-specific extra completion options."""
+    if isinstance(llm, BaseAnthropicProvider):
+        return {"cache_control": {"type": "ephemeral"}}
+    elif stream and isinstance(llm, BaseOpenAIProvider):
+        return {"stream_options": {"include_usage": True}}
+    return {}
 
 
 class ModelRunner:
@@ -84,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,
-                    stream_options=_stream_usage_options(llm, 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
@@ -176,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

{bub-0.4.0 → bub-0.4.2}/src/bub/builtin/settings.py

@@ -60,6 +60,7 @@ class AgentSettings(Settings):
     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 +80,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.0 → bub-0.4.2}/src/bub/builtin/tape.py

@@ -4,7 +4,7 @@ import contextlib
 import hashlib
 import inspect
 import json
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Mapping
 from dataclasses import asdict, dataclass, field, replace
 from datetime import UTC, datetime
 from pathlib import Path
@@ -33,6 +33,7 @@ class TapeInfo:
     last_anchor: str | None
     entries_since_last_anchor: int
     last_token_usage: int | None
+    last_token_cache_hit_rate: float | None
 
 
 @dataclass(frozen=True)
@@ -77,13 +78,29 @@ class Tape:
             last_anchor = None
             entries_since_last_anchor = len(entries)
         last_token_usage: int | None = None
+        last_token_cache_hit_rate: float | None = None
         for entry in reversed(entries):
             if entry.kind == "event" and entry.payload.get("name") == "run":
-                with contextlib.suppress(AttributeError):
-                    token_usage = entry.payload.get("data", {}).get("usage", {}).get("total_tokens")
-                    if token_usage and isinstance(token_usage, int):
-                        last_token_usage = token_usage
-                        break
+                data = entry.payload.get("data")
+                usage = data.get("usage") if isinstance(data, Mapping) else None
+                if not isinstance(usage, Mapping):
+                    continue
+                token_usage = usage.get("total_tokens")
+                if not isinstance(token_usage, int) or isinstance(token_usage, bool):
+                    continue
+                last_token_usage = token_usage
+                prompt_tokens = usage.get("prompt_tokens")
+                prompt_details = usage.get("prompt_tokens_details")
+                cached_tokens = prompt_details.get("cached_tokens") if isinstance(prompt_details, Mapping) else None
+                if (
+                    isinstance(prompt_tokens, int)
+                    and not isinstance(prompt_tokens, bool)
+                    and prompt_tokens > 0
+                    and isinstance(cached_tokens, int)
+                    and not isinstance(cached_tokens, bool)
+                ):
+                    last_token_cache_hit_rate = cached_tokens / prompt_tokens
+                break
         return TapeInfo(
             name=self.name,
             entries=len(entries),
@@ -91,6 +108,7 @@ class Tape:
             last_anchor=str(last_anchor) if last_anchor else None,
             entries_since_last_anchor=entries_since_last_anchor,
             last_token_usage=last_token_usage,
+            last_token_cache_hit_rate=last_token_cache_hit_rate,
         )
 
     async def ensure_bootstrap_anchor(self) -> None:

{bub-0.4.0 → bub-0.4.2}/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
@@ -253,16 +232,20 @@ def fs_edit(path: str, old: str, new: str, start: int = 0, *, context: ToolConte
 
 
 @tool(context=True, name="skill")
-def skill_describe(name: str, *, context: ToolContext) -> str:
-    """Load the skill content by name. Return the location and skill content."""
+def skill_describe(name: str | None = None, *, context: ToolContext) -> str:
+    """Load the skill content by name. Return the location and skill content.
+    If name is not provided, list all available skills in the current workspace.
+    """
     from bub.utils import workspace_from_state
 
     allowed_skills = context.state.get("allowed_skills")
-    if allowed_skills is not None and name.casefold() not in allowed_skills:
+    if allowed_skills is not None and name and name.casefold() not in allowed_skills:
         return f"(skill '{name}' is not allowed in this context)"
 
     workspace = workspace_from_state(context.state)
     skill_index = {skill.name: skill for skill in discover_skills(workspace)}
+    if name is None:
+        return "Available skills:\n" + "\n".join(f"- {skill.name}" for skill in skill_index.values())
     if name.casefold() not in skill_index:
         return "(no such skill)"
     skill = skill_index[name.casefold()]
@@ -273,13 +256,15 @@ def skill_describe(name: str, *, context: ToolContext) -> str:
 async def tape_info(context: ToolContext) -> str:
     """Get information about the current tape, such as number of entries and anchors."""
     info = await context.tape.info()
+    cache_hit_rate = f"{info.last_token_cache_hit_rate:.2%}" if info.last_token_cache_hit_rate is not None else "None"
     return (
         f"name: {info.name}\n"
         f"entries: {info.entries}\n"
         f"anchors: {info.anchors}\n"
         f"last_anchor: {info.last_anchor}\n"
         f"entries_since_last_anchor: {info.entries_since_last_anchor}\n"
-        f"last_token_usage: {info.last_token_usage}"
+        f"last_token_usage: {info.last_token_usage}\n"
+        f"last_token_cache_hit_rate: {cache_hit_rate}"
     )
 
 
@@ -370,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 (
@@ -393,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)
@@ -403,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.
 
@@ -419,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()