monkeybot 3.11.1__tar.gz → 3.12.0__tar.gz

monkeybot-3.12.0/.github/CODEOWNERS

@@ -0,0 +1 @@
+* @VibeEffect

{monkeybot-3.11.1 → monkeybot-3.12.0}/CHANGELOG.md

@@ -6,7 +6,13 @@ the project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
-### CLI
+## [core v3.12.0] - 2026-10-29
+
+### Added
+
+- Bedrock Converse models (Grok, Nova, Llama, and other non-Claude ids) send prompt-cache checkpoints when `model.cache_retention` is not `none`. Checkpoints land on the system prompt, the tool list, and the last two user turns, up to Bedrock's limit of four. `short` and `long` both use Converse's default 5-minute cache. A model that rejects cache points is retried once without them.
+
+## [cli v0.12.0] - 2026-10-28
 
 ### Changed
 

{monkeybot-3.11.1 → monkeybot-3.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: monkeybot
-Version: 3.11.1
+Version: 3.12.0
 Summary: monkeybot agent harness — FastAPI SSE gateway, owned loop, SQLite, and MCP.
 License: MIT
 License-File: LICENSE

{monkeybot-3.11.1 → monkeybot-3.12.0}/cli/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "monkeybot-cli"
-version = "0.11.1"
+version = "0.12.0"
 description = "CLI to create, configure, validate, and chat with monkeybot agents."
 requires-python = ">=3.11"
 dependencies = [

{monkeybot-3.11.1 → monkeybot-3.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "monkeybot"
-version = "3.11.1"
+version = "3.12.0"
 description = "monkeybot agent harness — FastAPI SSE gateway, owned loop, SQLite, and MCP."
 requires-python = ">=3.11"
 readme = "README.md"

{monkeybot-3.11.1 → monkeybot-3.12.0}/regression/drivers/bundles/workspace.py

@@ -10,7 +10,11 @@ from pathlib import Path
 from monkeybot.core.tools.core_tool_executor import CoreToolExecutor
 from regression.drivers.bundles.protocol import Bundle, LoopDriverError, RunCtx
 from regression.drivers.support.paths import _FIXTURE_PREFIXES, _WORKSPACE_ROOTS
-from regression.fixtures.build import HOSTILE_SOURCE, overlay_hostile
+from regression.fixtures.build import (
+    HOSTILE_SOURCE,
+    overlay_hostile,
+    refresh_seeded_attachment_clocks,
+)
 from regression.schema.scenario import Scenario
 from regression.schema.steps import TouchFileStep
 
@@ -114,6 +118,9 @@ def _materialize_workspace(scenario: Scenario, workdir: Path) -> tuple[Path | No
         hostile = hostile or _is_hostile_source(source)
     if hostile:
         _overlay_hostile_workspace(workspace, workdir)
+    # Seeded attachments carry a committed created_at_ms. Refresh after the
+    # copy so the store's wall-clock TTL does not expire the fixture.
+    refresh_seeded_attachment_clocks(workspace)
     if not wants_tree:
         return workspace, None
     pristine = workdir / "pristine"

{monkeybot-3.11.1 → monkeybot-3.12.0}/regression/fixtures/build.py

@@ -16,8 +16,10 @@ copying the committed tree (for example when ``workspace_fixture`` is
 
 from __future__ import annotations
 
+import json
 import os
 import shutil
+import time
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -131,3 +133,33 @@ def build(dest: Path) -> BuiltFixtures:
         link_target=link_target.resolve(),
         skill_target=skill_target.resolve(),
     )
+
+
+def refresh_seeded_attachment_clocks(workspace: Path, *, now_ms: int | None = None) -> None:
+    """Stamp copied attachment sidecars as just stored.
+
+    TTL is wall-clock (``ATTACHMENT_TTL_HOURS``, default 48). A committed
+    ``created_at_ms`` expires the fixture even though the bytes are still the
+    scenario's input. Symlinked sidecars are left alone so a leaf that points
+    outside the workspace is not rewritten.
+    """
+    root = workspace / ".monkeybot" / "attachments"
+    if not root.is_dir() or root.is_symlink():
+        return
+    stamped = int(time.time() * 1000) if now_ms is None else now_ms
+    root_resolved = root.resolve()
+    for meta_path in root.rglob("*.json"):
+        if meta_path.is_symlink() or not meta_path.is_file():
+            continue
+        try:
+            meta_path.resolve().relative_to(root_resolved)
+        except ValueError:
+            continue
+        try:
+            raw = json.loads(meta_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            continue
+        if not isinstance(raw, dict) or "created_at_ms" not in raw:
+            continue
+        raw["created_at_ms"] = stamped
+        meta_path.write_text(json.dumps(raw), encoding="utf-8")

{monkeybot-3.11.1 → monkeybot-3.12.0}/regression/selftest/test_fixtures.py

@@ -51,6 +51,7 @@ from regression.fixtures.build import (
     SKILLS_SOURCE,
     BuiltFixtures,
     build,
+    refresh_seeded_attachment_clocks,
 )
 
 REPO = Path(__file__).resolve().parents[2]
@@ -352,6 +353,26 @@ def test_attachments_match_their_kinds() -> None:
     assert _extract_pdf_text_sync(base64.b64encode(without_text).decode(), 1000) is None
 
 
+def test_seeded_attachment_clocks_are_restamped_on_the_copy(tmp_path: Path) -> None:
+    session = tmp_path / ".monkeybot" / "attachments" / "loop-scenario"
+    session.mkdir(parents=True)
+    meta = session / "att-pdf.json"
+    meta.write_text(
+        json.dumps({"attachment_id": "att-pdf", "created_at_ms": 1}),
+        encoding="utf-8",
+    )
+    outside = tmp_path / "outside.json"
+    outside.write_text(json.dumps({"created_at_ms": 1}), encoding="utf-8")
+    (session / "att-link.json").symlink_to(outside)
+    (session / "note.json").write_text(json.dumps({"filename": "x"}), encoding="utf-8")
+
+    refresh_seeded_attachment_clocks(tmp_path, now_ms=1234)
+
+    assert json.loads(meta.read_text(encoding="utf-8"))["created_at_ms"] == 1234
+    assert json.loads(outside.read_text(encoding="utf-8"))["created_at_ms"] == 1
+    assert "created_at_ms" not in json.loads((session / "note.json").read_text(encoding="utf-8"))
+
+
 def test_subagent_tapes_are_present() -> None:
     root = FIXTURES / "subagent_tapes"
     names = sorted(path.name for path in root.glob("*.ndjson"))

{monkeybot-3.11.1 → monkeybot-3.12.0}/regression/t4/scenario_loader.py

@@ -17,6 +17,7 @@ from typing import Any, Literal
 import yaml
 from pydantic import BaseModel, Field
 
+from regression.fixtures.build import refresh_seeded_attachment_clocks
 from regression.schema.scenario import Scenario as SchemaScenario
 from regression.schema.scenario import load_scenario
 from regression.t4.models import Scenario
@@ -217,6 +218,7 @@ def materialize_workspace(
         if not overlay_dir.is_dir():
             raise FileNotFoundError(f"workspace_overlay not found: {overlay_dir}")
         shutil.copytree(overlay_dir, dest, dirs_exist_ok=True)
+    refresh_seeded_attachment_clocks(dest)
 
     def sub(text: str) -> str:
         return text.replace("{workspace_subdir}", subdir)

{monkeybot-3.11.1 → monkeybot-3.12.0}/src/monkeybot/providers/_bedrock_converse.py

@@ -8,7 +8,7 @@ import json
 import logging
 import re
 from collections.abc import AsyncIterator, Iterator, Sequence
-from typing import Any
+from typing import Any, Literal
 
 from monkeybot.core.llm.provider import (
     Done,
@@ -45,7 +45,11 @@ _log = logging.getLogger(__name__)
 
 _EMPTY_TOOL_RESULT = "(no output)"
 _UNSUPPORTED_FIELD_RE = re.compile(r"doesn't support the (\w+) field", re.IGNORECASE)
+_CACHE_BLAME_RE = re.compile(r"cache\s*point|caching", re.IGNORECASE)
 _SENTINEL = object()
+_MAX_CONVERSE_CACHE_POINTS = 4
+_CACHE_POINT_BLOCK: dict[str, Any] = {"cachePoint": {"type": "default"}}
+_CACHEPOINT_UNSUPPORTED: set[str] = set()
 _DOC_FORMATS = {
     "pdf": "pdf",
     "csv": "csv",
@@ -254,6 +258,118 @@ def messages_to_converse(messages: Sequence[Message]) -> tuple[str, list[dict[st
     return system, out
 
 
+def _copy_content_blocks(blocks: list[Any]) -> list[Any]:
+    return [dict(b) if isinstance(b, dict) else b for b in blocks]
+
+
+def _append_cache_point_to_system(system: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    return _copy_content_blocks(system) + [dict(_CACHE_POINT_BLOCK)]
+
+
+def _append_cache_point_to_tools(tool_config: dict[str, Any]) -> dict[str, Any]:
+    tools = tool_config.get("tools")
+    if not isinstance(tools, list) or not tools:
+        return dict(tool_config)
+    return {
+        **tool_config,
+        "tools": _copy_content_blocks(tools) + [dict(_CACHE_POINT_BLOCK)],
+    }
+
+
+def _append_cache_points_to_last_user_messages(
+    messages: list[dict[str, Any]],
+    *,
+    max_points: int,
+) -> list[dict[str, Any]]:
+    if max_points < 1:
+        return [
+            dict(m, content=_copy_content_blocks(list(m.get("content") or []))) for m in messages
+        ]
+    user_indices = [i for i, m in enumerate(messages) if m.get("role") == "user"]
+    targets = set(user_indices[-2:])
+    out: list[dict[str, Any]] = []
+    budget = max_points
+    for i, msg in enumerate(messages):
+        content = _copy_content_blocks(list(msg.get("content") or []))
+        if i in targets and budget > 0:
+            content.append(dict(_CACHE_POINT_BLOCK))
+            budget -= 1
+        out.append({"role": msg["role"], "content": content})
+    return out
+
+
+def _apply_cache_points(kwargs: dict[str, Any]) -> dict[str, Any]:
+    """Insert Converse ``cachePoint`` blocks (max 4). Returns a shallow copy of ``kwargs``."""
+    out = dict(kwargs)
+    budget = _MAX_CONVERSE_CACHE_POINTS
+
+    system = out.get("system")
+    if isinstance(system, list) and system and budget > 0:
+        out["system"] = _append_cache_point_to_system(system)
+        budget -= 1
+
+    tool_config = out.get("toolConfig")
+    if isinstance(tool_config, dict) and budget > 0:
+        tools = tool_config.get("tools")
+        if isinstance(tools, list) and tools:
+            out["toolConfig"] = _append_cache_point_to_tools(tool_config)
+            budget -= 1
+
+    messages = out.get("messages")
+    if isinstance(messages, list) and budget > 0:
+        out["messages"] = _append_cache_points_to_last_user_messages(messages, max_points=budget)
+
+    return out
+
+
+def _strip_cache_points(kwargs: dict[str, Any]) -> bool:
+    """Remove every ``cachePoint`` block from kwargs. Returns True if any were removed."""
+    removed = False
+
+    system = kwargs.get("system")
+    if isinstance(system, list):
+        filtered = [b for b in system if not (isinstance(b, dict) and "cachePoint" in b)]
+        if len(filtered) != len(system):
+            removed = True
+            kwargs["system"] = filtered
+
+    tool_config = kwargs.get("toolConfig")
+    if isinstance(tool_config, dict):
+        tools = tool_config.get("tools")
+        if isinstance(tools, list):
+            filtered_tools = [t for t in tools if not (isinstance(t, dict) and "cachePoint" in t)]
+            if len(filtered_tools) != len(tools):
+                removed = True
+                kwargs["toolConfig"] = {**tool_config, "tools": filtered_tools}
+
+    messages = kwargs.get("messages")
+    if isinstance(messages, list):
+        new_messages: list[dict[str, Any]] = []
+        for msg in messages:
+            if not isinstance(msg, dict):
+                new_messages.append(msg)
+                continue
+            content = msg.get("content")
+            if isinstance(content, list):
+                filtered_content = [
+                    b for b in content if not (isinstance(b, dict) and "cachePoint" in b)
+                ]
+                if len(filtered_content) != len(content):
+                    removed = True
+                    new_messages.append({**msg, "content": filtered_content})
+                    continue
+            new_messages.append(dict(msg))
+        kwargs["messages"] = new_messages
+
+    return removed
+
+
+def _exc_blames_cache(exc: BaseException) -> bool:
+    if "validation" not in type(exc).__name__.lower():
+        return False
+    return _CACHE_BLAME_RE.search(str(exc)) is not None
+
+
 def converse_request_kwargs(
     *,
     model: str,
@@ -261,13 +377,13 @@ def converse_request_kwargs(
     tools: Sequence[ToolDef],
     max_tokens: int,
     temperature: float,
+    cache_retention: Literal["none", "short", "long"] = "short",
 ) -> dict[str, Any]:
     """Build ``converse_stream`` kwargs. Always sets ``inferenceConfig.maxTokens``.
 
-    ``hints.cache_retention`` / Converse ``cachePoint`` blocks are not wired on
-    this path. Claude still uses ``prepare_anthropic_cached_payload``; Nova/Llama
-    cache points are a follow-up. ``UsageEvent.cache_read_tokens`` staying 0
-    means caching was never requested, not that the model refused a cache hit.
+    When ``cache_retention`` is not ``none``, inserts Converse ``cachePoint`` blocks
+    on system, tools, and the last two user turns (Bedrock max 4). ``short`` and
+    ``long`` both use the default 5-minute Converse cache tier.
 
     ``thinking_budget`` is not forwarded on this path — Converse reasoning is not
     requested via ``additionalModelRequestFields`` yet; the mapper only round-trips
@@ -287,6 +403,8 @@ def converse_request_kwargs(
     tool_config = converse_tools(tools)
     if tool_config is not None:
         kwargs["toolConfig"] = tool_config
+    if cache_retention != "none":
+        kwargs = _apply_cache_points(kwargs)
     return kwargs
 
 
@@ -549,19 +667,44 @@ async def iter_converse_stream(
 ) -> AsyncIterator[ProviderEvent]:
     """Stream ``converse_stream``, retrying once a rejected inference field is stripped."""
     kwargs = _copy_stream_kwargs(stream_kwargs)
-    async for event in iter_stream_with_param_retry(
-        lambda kw: _stream_converse_once(client, kw, provider=provider),
-        kwargs,
-        strip_rejected=_strip_unsupported_inference,
-        max_attempts=2,
-        provider=provider,
-        error_message=error_message,
-        model=kwargs.get("modelId"),
-        n_messages=n_messages,
-        n_tools=n_tools,
-        retry_message="converse stream rejected params, retrying without them %s",
-    ):
-        yield event
+    model_id = str(kwargs.get("modelId") or "")
+    if model_id in _CACHEPOINT_UNSUPPORTED:
+        _strip_cache_points(kwargs)
+
+    async def _run_param_retry() -> AsyncIterator[ProviderEvent]:
+        async for event in iter_stream_with_param_retry(
+            lambda kw: _stream_converse_once(client, kw, provider=provider),
+            kwargs,
+            strip_rejected=_strip_unsupported_inference,
+            max_attempts=2,
+            provider=provider,
+            error_message=error_message,
+            model=kwargs.get("modelId"),
+            n_messages=n_messages,
+            n_tools=n_tools,
+            retry_message="converse stream rejected params, retrying without them %s",
+        ):
+            yield event
+
+    started = False
+    try:
+        async for event in _run_param_retry():
+            started = True
+            yield event
+    except Exception as exc:
+        if started or not _exc_blames_cache(exc):
+            raise
+        if not _strip_cache_points(kwargs):
+            raise
+        if model_id and model_id not in _CACHEPOINT_UNSUPPORTED:
+            _log.warning(
+                "converse cachePoint rejected, retrying without caching %s",
+                kv(provider=provider, model=model_id),
+            )
+        if model_id:
+            _CACHEPOINT_UNSUPPORTED.add(model_id)
+        async for event in _run_param_retry():
+            yield event
 
 
 def _estimate_block(block: ContentBlock) -> dict[str, Any]:

{monkeybot-3.11.1 → monkeybot-3.12.0}/src/monkeybot/providers/bedrock.py

@@ -179,12 +179,14 @@ class BedrockProvider:
                 "Bedrock dispatch %s",
                 kv(provider="bedrock", model=model, path="converse"),
             )
+            retention = hints.cache_retention if hints is not None else "short"
             kwargs = converse_request_kwargs(
                 model=model,
                 messages=messages,
                 tools=tools,
                 max_tokens=self._max_tokens,
                 temperature=self._temperature,
+                cache_retention=retention,
             )
             client = await self._runtime_client()
             async for event in iter_converse_stream(

{monkeybot-3.11.1 → monkeybot-3.12.0}/tests/unit/providers/test_bedrock_converse.py

@@ -51,6 +51,28 @@ _NOVA = "us.amazon.nova-pro-v1:0"
 _CLAUDE = "us.anthropic.claude-sonnet-4-6"
 
 
+def _count_cache_points(obj: object) -> int:
+    n = 0
+    if isinstance(obj, dict):
+        if "cachePoint" in obj:
+            n += 1
+        for value in obj.values():
+            n += _count_cache_points(value)
+    elif isinstance(obj, list):
+        for item in obj:
+            n += _count_cache_points(item)
+    return n
+
+
+def _long_user_history(n_user_turns: int) -> list[Message]:
+    messages: list[Message] = [Message.text("system", "You are helpful.")]
+    for i in range(n_user_turns):
+        messages.append(Message.text("user", f"turn-{i}"))
+        messages.append(Message.text("assistant", f"reply-{i}"))
+    messages.append(Message.text("user", "latest"))
+    return messages
+
+
 @pytest.mark.parametrize(
     ("model_id", "vendor"),
     [
@@ -111,6 +133,72 @@ def test_grok_kwargs_omit_temperature_nova_keeps_it() -> None:
     assert supports_param(_NOVA, "temperature") is True
 
 
+def test_converse_cache_points_default_retention() -> None:
+    messages = [
+        Message.text("system", "You are helpful."),
+        Message.text("user", "first"),
+        Message.text("assistant", "ok"),
+        Message.text("user", "second"),
+    ]
+    kwargs = converse_request_kwargs(
+        model=_NOVA,
+        messages=messages,
+        tools=[_ECHO],
+        max_tokens=256,
+        temperature=0.2,
+    )
+    assert kwargs["system"][-1] == {"cachePoint": {"type": "default"}}
+    assert kwargs["toolConfig"]["tools"][-1] == {"cachePoint": {"type": "default"}}
+    user_msgs = [m for m in kwargs["messages"] if m["role"] == "user"]
+    assert user_msgs[-2]["content"][-1] == {"cachePoint": {"type": "default"}}
+    assert user_msgs[-1]["content"][-1] == {"cachePoint": {"type": "default"}}
+    assert _count_cache_points(kwargs) == 4
+
+
+def test_converse_cache_points_cap_with_long_history() -> None:
+    kwargs = converse_request_kwargs(
+        model=_GROK,
+        messages=_long_user_history(20),
+        tools=[_ECHO],
+        max_tokens=256,
+        temperature=0.2,
+    )
+    assert _count_cache_points(kwargs) == 4
+
+
+def test_converse_cache_retention_none() -> None:
+    kwargs = converse_request_kwargs(
+        model=_NOVA,
+        messages=[
+            Message.text("system", "sys"),
+            Message.text("user", "hi"),
+        ],
+        tools=[_ECHO],
+        max_tokens=64,
+        temperature=0.2,
+        cache_retention="none",
+    )
+    assert _count_cache_points(kwargs) == 0
+
+
+def test_converse_request_kwargs_does_not_mutate_messages() -> None:
+    messages = [
+        Message.text("system", "sys"),
+        Message.text("user", "one"),
+        Message.text("assistant", "two"),
+        Message.text("user", "three"),
+    ]
+    before = repr(messages)
+    converse_request_kwargs(
+        model=_NOVA,
+        messages=messages,
+        tools=[_ECHO],
+        max_tokens=64,
+        temperature=0.2,
+    )
+    assert repr(messages) == before
+
+
 def test_tool_round_trip_tooluse_and_toolresult() -> None:
     messages = [
         Message.text("user", "hi"),
@@ -476,6 +564,131 @@ async def test_retry_strips_temperature_after_validation_exception() -> None:
     assert any(isinstance(e, TextDelta) and e.text == "ok" for e in events)
 
 
+class CacheValidationError(Exception):
+    """Stand-in for Bedrock ValidationException naming."""
+
+
+@pytest.mark.asyncio
+async def test_iter_converse_stream_retries_without_cache_points(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        "monkeybot.providers._bedrock_converse._CACHEPOINT_UNSUPPORTED",
+        set(),
+    )
+    calls: list[dict[str, object]] = []
+
+    def converse_stream(**kwargs: object) -> dict[str, object]:
+        calls.append(dict(kwargs))
+        if _count_cache_points(kwargs) > 0:
+            raise CacheValidationError("cachePoint is not supported for this model")
+        return {"stream": iter(_text_stream())}
+
+    client = MagicMock()
+    client.converse_stream.side_effect = converse_stream
+    stream_kwargs = converse_request_kwargs(
+        model=_GROK,
+        messages=[Message.text("system", "sys"), Message.text("user", "hi")],
+        tools=[_ECHO],
+        max_tokens=32,
+        temperature=0.2,
+    )
+    assert _count_cache_points(stream_kwargs) > 0
+    events = [
+        e
+        async for e in iter_converse_stream(
+            client,
+            stream_kwargs,
+            provider="bedrock",
+            error_message="err %s",
+        )
+    ]
+    assert len(calls) == 2
+    assert _count_cache_points(calls[0]) > 0
+    assert _count_cache_points(calls[1]) == 0
+    assert any(isinstance(e, TextDelta) and e.text == "ok" for e in events)
+
+    calls.clear()
+    async for _ in iter_converse_stream(
+        client,
+        stream_kwargs,
+        provider="bedrock",
+        error_message="err %s",
+    ):
+        pass
+    assert len(calls) == 1
+    assert _count_cache_points(calls[0]) == 0
+
+
+@pytest.mark.asyncio
+async def test_iter_converse_stream_reraises_cache_error_mid_stream() -> None:
+    class _Stream:
+        def __init__(self) -> None:
+            self._events = iter(
+                [
+                    {"contentBlockDelta": {"delta": {"text": "partial"}}},
+                ]
+            )
+
+        def __iter__(self) -> _Stream:
+            return self
+
+        def __next__(self) -> dict[str, object]:
+            try:
+                return next(self._events)
+            except StopIteration as exc:
+                raise CacheValidationError("invalid cachePoint block") from exc
+
+    client = MagicMock()
+    client.converse_stream.return_value = {"stream": _Stream()}
+    with pytest.raises(CacheValidationError, match="cachePoint"):
+        async for _ in iter_converse_stream(
+            client,
+            converse_request_kwargs(
+                model=_GROK,
+                messages=[Message.text("user", "hi")],
+                tools=[],
+                max_tokens=8,
+                temperature=0.2,
+            ),
+            provider="bedrock",
+            error_message="err %s",
+        ):
+            pass
+
+
+@pytest.mark.asyncio
+async def test_converse_usage_maps_cache_token_fields() -> None:
+    stream_events: list[dict[str, object]] = [
+        {"messageStop": {"stopReason": "end_turn"}},
+        {
+            "metadata": {
+                "usage": {
+                    "inputTokens": 10,
+                    "outputTokens": 3,
+                    "cacheReadInputTokens": 80,
+                    "cacheWriteInputTokens": 20,
+                }
+            }
+        },
+    ]
+    client = MagicMock()
+    client.converse_stream.return_value = {"stream": iter(stream_events)}
+    events = [
+        e
+        async for e in iter_converse_stream(
+            client,
+            {"modelId": _GROK, "messages": [], "inferenceConfig": {"maxTokens": 8}},
+            provider="bedrock",
+            error_message="err %s",
+        )
+    ]
+    usage = next(e for e in events if isinstance(e, UsageEvent))
+    assert usage.cache_read_tokens == 80
+    assert usage.cache_creation_tokens == 20
+    assert usage.cached_tokens == 100
+
+
 @pytest.mark.asyncio
 async def test_unexpected_stream_event_is_logged(caplog: pytest.LogCaptureFixture) -> None:
     client = MagicMock()

{monkeybot-3.11.1 → monkeybot-3.12.0}/uv.lock

@@ -2453,7 +2453,7 @@ wheels = [
 
 [[package]]
 name = "monkeybot"
-version = "3.11.0"
+version = "3.11.1"
 source = { editable = "." }
 dependencies = [
     { name = "aiosqlite" },
@@ -2717,7 +2717,7 @@ dev = [{ name = "pytest", specifier = ">=8.0.0" }]
 
 [[package]]
 name = "monkeybot-cli"
-version = "0.11.1"
+version = "0.12.0"
 source = { editable = "cli" }
 dependencies = [
     { name = "httpx" },