code-puppy 0.0.910__tar.gz → 0.0.911__tar.gz

{code_puppy-0.0.910 → code_puppy-0.0.911}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy
-Version: 0.0.910
+Version: 0.0.911
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.910 → code_puppy-0.0.911}/code_puppy/agents/_builder.py

@@ -726,7 +726,7 @@ def build_pydantic_agent(
                 history_compaction,
                 ProcessHistory(steer_processor),
                 build_response_clamp(),
-                build_model_message_transform(logical_agent_name),
+                build_model_message_transform(logical_agent_name, agent),
                 # Sub-agent recursion guards on the wrap_tool_execute seam
                 # (denies invoke_agent calls past the depth caps before the
                 # tool body runs). Sole wrap_tool_execute implementer, so

{code_puppy-0.0.910 → code_puppy-0.0.911}/code_puppy/agents/_compaction.py

@@ -64,6 +64,7 @@ from code_puppy.config import (
     get_protected_token_count,
     get_summarization_model_name,
 )
+from code_puppy.context_accounting import context_tokens, model_names
 from code_puppy.messaging import emit_warning
 
 # Kept importable at module level for the context-indicator plugin, which
@@ -202,7 +203,12 @@ class CodePuppyCompactionStore:
         return self.agent._get_model_context_length()
 
     def context_overhead(self) -> int:
-        return self.agent._estimate_context_overhead()
+        overhead = self.agent._estimate_context_overhead()
+        # Cached so the outbound-request stamp (``_model_message_transform``)
+        # can report the exact overhead this measurement used, instead of
+        # re-deriving a possibly-different value moments later.
+        self.agent._context_overhead = overhead
+        return overhead
 
     def model_name(self) -> Optional[str]:
         if self.agent is None:
@@ -225,6 +231,17 @@ def _take_forced_compaction_request() -> bool:
     return get_pause_controller().take_compaction_request()
 
 
+def _total_tokens(messages, model, overhead) -> int:
+    """Anchor the whole-history total to the live request model's identity.
+
+    Wired as the capability's ``total_estimator`` -- see
+    ``code_puppy.context_accounting.context_tokens`` for the anchor/fallback
+    logic. Kept as a module-level function (not a lambda) so it shows up by
+    name in tracebacks and can be monkeypatched directly in tests.
+    """
+    return context_tokens(messages, model_names(model), overhead)
+
+
 def build_history_compaction(agent: Any) -> PureHistoryCompaction:
     """Build the pure ``HistoryCompaction`` capability wired to Code Puppy.
 
@@ -243,6 +260,7 @@ def build_history_compaction(agent: Any) -> PureHistoryCompaction:
         strategy_name=lambda: get_compaction_strategy(),
         compaction_threshold=lambda: get_compaction_threshold(),
         token_estimator=estimate_tokens_for_message,
+        total_estimator=_total_tokens,
         message_hasher=hash_message,
         history_sanitizer=sanitize_tool_call_ids,
         force_poll=_take_forced_compaction_request,

code_puppy-0.0.911/code_puppy/agents/_model_message_transform.py

@@ -0,0 +1,130 @@
+"""Plugin transforms for final outbound model messages."""
+
+from copy import copy
+from typing import Any
+
+from pydantic_ai import RunContext
+from pydantic_ai.capabilities import Hooks, WrapModelRequestHandler
+from pydantic_ai.messages import ModelResponse
+from pydantic_ai.models import ModelRequestContext
+from pydantic_ai.models.wrapper import WrapperModel
+
+from code_puppy.agents._foreign_thinking import strip_foreign_thinking
+from code_puppy.callbacks import on_transform_model_messages
+
+# Per-request prefix fingerprint, handed from the ``wrap_model_request`` leg
+# to the ``after_model_request`` leg via this attribute on the (mutable,
+# per-request) ``ModelRequestContext``. ``None`` means "this request's
+# outbound messages diverged from the durable history it was built from, so
+# don't stamp an anchor" -- see ``build_model_message_transform``.
+_PREFIX_ATTR = "_context_accounting_prefix"
+
+
+class _ContinuationObserver(WrapperModel):
+    """Observe a suspended->continued chain *before* pydantic-ai merges it.
+
+    ``continuation_delay`` runs on intermediate suspended responses before
+    their usage can merge. This request-local wrapper preserves the real
+    model's delay behavior while marking the final response ineligible for
+    a receipt. The framework's durable-execution capabilities use the same
+    request-model swap seam. Provider details and billing limitations live
+    in ``docs/API_CONTEXT_ACCOUNTING.md``.
+    """
+
+    def __init__(self, wrapped):
+        super().__init__(wrapped)
+        self.continued = False
+
+    def continuation_delay(self, response: ModelResponse) -> float | None:
+        self.continued = True
+        return super().continuation_delay(response)
+
+
+def build_model_message_transform(agent_name: str | None, owner: Any = None) -> Hooks:
+    """Build the request-only plugin transform for an agent.
+
+    ``owner`` is the Code Puppy agent (or agent-shaped object) whose
+    ``_context_overhead`` compaction just computed for this same request --
+    see ``CodePuppyCompactionStore.context_overhead``. Passing it lets the
+    stamped receipt record the *exact* overhead the compaction trigger used,
+    so the next request's ``context_tokens`` call reconstructs the same
+    total instead of silently drifting by whatever overhead changed between
+    the two reads. ``None`` (sub-agents/tests that don't wire one) just
+    stamps ``overhead=0``, which only costs an extra estimate on that one
+    anchor -- never a wrong total, because ``context_tokens`` always folds
+    the caller's *current* overhead back in.
+    """
+
+    async def transform(
+        _ctx: RunContext[Any],
+        *,
+        request_context: ModelRequestContext,
+        handler: WrapModelRequestHandler,
+    ) -> ModelResponse:
+        from code_puppy.context_accounting import fingerprint, invalidate_anchors
+
+        durable_messages = request_context.messages
+        # Snapshot *before* anything can touch the messages. strip_foreign_thinking
+        # is a no-op pass-through for non-Anthropic models (same list AND same
+        # message objects by reference, not a copy) -- so a plugin transform
+        # that mutates in place would otherwise mutate ``durable_messages`` too,
+        # and a fingerprint taken afterwards would never see the divergence.
+        original_fingerprint = fingerprint(durable_messages)
+
+        transformed_context = copy(request_context)
+        transformed_context.messages = strip_foreign_thinking(
+            list(durable_messages), request_context.model
+        )
+        await on_transform_model_messages(agent_name, transformed_context.messages)
+
+        # The anchor must describe what the *durable history* looked like,
+        # because that's what next turn's ``context_tokens`` re-fingerprints
+        # against. If anything between the snapshot above and the handler
+        # call -- the built-in foreign-thinking strip, or a plugin's rewrite,
+        # in place or not -- changed what's actually sent, the response's
+        # usage no longer describes ``durable_messages`` and must not anchor it.
+        prefix = original_fingerprint
+        if fingerprint(transformed_context.messages) != prefix:
+            prefix = None
+
+        # Wrap *after* the fingerprint check above (which needs the real
+        # model for foreign-thinking detection) and *before* the handler
+        # call, so the continuation loop inside `handler` actually drives
+        # this wrapper's `continuation_delay` -- see `_ContinuationObserver`.
+        observer = _ContinuationObserver(transformed_context.model)
+        transformed_context.model = observer
+
+        try:
+            response = await handler(transformed_context)
+        except BaseException:
+            invalidate_anchors(durable_messages)
+            raise
+
+        if observer.continued:
+            # Usage on `response` is a cumulative sum across segments, not
+            # one measured prompt -- decline to anchor it. Billing/usage
+            # itself is untouched; only our own receipt is suppressed.
+            prefix = None
+        setattr(request_context, _PREFIX_ATTR, prefix)
+        return response
+
+    async def stamp(
+        _ctx: RunContext[Any],
+        *,
+        request_context: ModelRequestContext,
+        response: ModelResponse,
+    ) -> ModelResponse:
+        from code_puppy.context_accounting import model_names, record_anchor
+
+        prefix = getattr(request_context, _PREFIX_ATTR, None)
+        if prefix is not None:
+            record_anchor(
+                request_context.messages,
+                response,
+                context_overhead=getattr(owner, "_context_overhead", 0),
+                prefix=prefix,
+                request_model=model_names(request_context.model),
+            )
+        return response
+
+    return Hooks(model_request=transform, after_model_request=stamp)

{code_puppy-0.0.910 → code_puppy-0.0.911}/code_puppy/capabilities/compaction.py

@@ -24,7 +24,7 @@ from typing import Any, Callable, List, Optional, Protocol, Set, Tuple
 from pydantic_ai import CapabilityEvent
 from pydantic_ai.capabilities import AbstractCapability
 from pydantic_ai.messages import ModelMessage, ModelResponse, ThinkingPart
-from pydantic_ai.models import ModelRequestContext
+from pydantic_ai.models import Model, ModelRequestContext
 from pydantic_ai.tools import RunContext
 from pydantic_ai.usage import RunUsage
 
@@ -255,6 +255,17 @@ class HistoryCompaction(AbstractCapability[Any]):
     message_hasher: Callable[[ModelMessage], str]
     """Stable content hash used for merge dedup + dropped tracking."""
 
+    total_estimator: Optional[Callable[[List[ModelMessage], Model, int], int]] = None
+    """Optional whole-history total, given the resolved request model.
+
+    When set, this replaces ``sum(token_estimator(...)) + context_overhead``
+    for both the pre- and post-compaction measurement. The seam exists so an
+    application can anchor the total to a provider-reported usage figure
+    instead of a per-message heuristic sum, without this module knowing
+    anything about how that anchor is produced or stored. ``None`` keeps the
+    historical sum-based behavior.
+    """
+
     history_sanitizer: Optional[Callable[[List[ModelMessage]], List[ModelMessage]]] = (
         None
     )
@@ -350,6 +361,24 @@ class HistoryCompaction(AbstractCapability[Any]):
         )
         return cleaned
 
+    def _total(
+        self,
+        ctx: RunContext[Any],
+        messages: List[ModelMessage],
+        model_name: Optional[str],
+        context_overhead: int,
+    ) -> int:
+        """Resolve the whole-history total via ``total_estimator`` if wired.
+
+        Falls back to the historical ``sum(token_estimator) + overhead`` when
+        no ``total_estimator`` was injected, so callers that never wire one
+        see unchanged behavior.
+        """
+        if self.total_estimator is not None:
+            return self.total_estimator(messages, ctx.model, context_overhead)
+        message_tokens = sum(self.token_estimator(m, model_name) for m in messages)
+        return message_tokens + context_overhead
+
     async def measure_and_compact(
         self,
         ctx: RunContext[Any],
@@ -366,8 +395,7 @@ class HistoryCompaction(AbstractCapability[Any]):
         always survive a failed compaction.
         """
         model_name = self.store.model_name()
-        message_tokens = sum(self.token_estimator(m, model_name) for m in messages)
-        total_tokens = message_tokens + context_overhead
+        total_tokens = self._total(ctx, messages, model_name, context_overhead)
         proportion_used = total_tokens / model_max if model_max else 0.0
 
         await _safe_emit(
@@ -425,8 +453,12 @@ class HistoryCompaction(AbstractCapability[Any]):
         dropped = [m for m in messages if self.message_hasher(m) not in result_hashes]
 
         # Parity with the historical implementation: the post-compaction
-        # measurement reports message tokens only (no overhead term).
-        final_token_count = sum(self.token_estimator(m, model_name) for m in result)
+        # measurement reports message tokens only (no overhead term). A
+        # ``total_estimator`` naturally falls back to the same "message
+        # tokens only" shape here too -- compaction just removed the
+        # earlier prefix an anchor would need, so the anchor fingerprint
+        # can never match and the estimator sums the (now-shorter) result.
+        final_token_count = self._total(ctx, result, model_name, 0)
         await _safe_emit(
             ctx,
             ContextUsageMeasuredEvent(

code_puppy-0.0.911/code_puppy/context_accounting.py

@@ -0,0 +1,154 @@
+"""Context totals anchored to completed API requests, with a heuristic delta.
+
+A receipt identifies the unchanged measured prefix, response and request
+model; new content and changed overhead remain estimates. Invalid receipts
+fall back rather than reuse stale usage. Continuation-merged responses do
+not anchor because cumulative billing is not a single measured prompt.
+
+Design, provider limitations and rollout semantics are documented in
+``docs/API_CONTEXT_ACCOUNTING.md``. The request hook owns continuation
+observation; this module never alters provider usage or billing.
+"""
+
+import hashlib
+import json
+
+from pydantic_ai.messages import ModelMessagesTypeAdapter, ModelResponse, TextPart
+
+
+def estimate_tokens_for_message(message, model_name):
+    """Import lazily so the shared entry point has no agent-package cycle."""
+    from code_puppy.agents._history import estimate_tokens_for_message as estimate
+
+    return estimate(message, model_name)
+
+
+_ANCHOR = "context_anchor"
+
+
+def fingerprint(messages) -> str:
+    """Include arguments, signatures and binary payloads, excluding receipts.
+
+    Receipts live under ``metadata`` so stamping one does not change the
+    fingerprint of the message it rides on -- otherwise a receipt would
+    invalidate itself the instant it was written.
+    """
+    clean = ModelMessagesTypeAdapter.dump_python(messages, mode="json")
+    payload = [
+        {
+            key: value
+            for key, value in message.items()
+            if key in {"parts", "instructions", "kind"}
+        }
+        for message in clean
+    ]
+    return hashlib.sha256(json.dumps(payload, sort_keys=True).encode()).hexdigest()
+
+
+def record_anchor(
+    messages, response, *, context_overhead=0, prefix=None, request_model=None
+):
+    """Stamp only a successfully completed response; usage is never fabricated.
+
+    Trusts ``prefix`` and ``response.usage`` as given -- it has no way to
+    tell a continuation-merged (cumulative) usage from an ordinary one on
+    its own. The caller must not call this helper when a continuation was observed
+    (see ``_ContinuationObserver`` in ``agents/_model_message_transform.py``).
+    Here, ``prefix=None`` computes a fingerprint; it does not suppress stamping.
+    """
+    if (
+        response.usage.input_tokens <= 0
+        or not response.model_name
+        or response.state != "complete"
+    ):
+        return
+    response.metadata = dict(response.metadata or {})
+    response.metadata[_ANCHOR] = {
+        "prefix": prefix if prefix is not None else fingerprint(messages),
+        "response": fingerprint([response]),
+        "overhead": context_overhead,
+        "request_models": sorted(
+            request_model
+            if isinstance(request_model, frozenset)
+            else {request_model if request_model is not None else response.model_name}
+        ),
+    }
+
+
+def invalidate_anchors(messages):
+    """Conservatively decline anchors after an unsuccessful request.
+
+    This is a deliberate failed-request policy, not proof the old measurement
+    became invalid. An unchanged prefix could retain its previous receipt,
+    and a retained partial response already forces fallback. We nevertheless
+    choose full estimation until a fresh completion; changing that contract
+    requires reconsidering the failure/cancellation regressions together.
+    """
+    for message in messages:
+        if isinstance(message, ModelResponse) and message.metadata:
+            message.metadata.pop(_ANCHOR, None)
+
+
+def context_tokens(messages, model_name, context_overhead=0) -> int:
+    """One total for compaction, the status bar, and context metadata.
+
+    API input includes system/tool/cache tokens. Plain text output usage is
+    an incremental approximation; it may include hidden reasoning when no
+    ThinkingPart is exposed, conservatively overestimating replay. Visible
+    reasoning/tool replay is estimated instead.
+    Only the latest response may anchor: partial/zero usage must not cause a
+    silent rewind to an older observation.
+    """
+    names = model_name if isinstance(model_name, frozenset) else {model_name}
+    estimate_model = next(iter(names)) if len(names) == 1 else None
+    for index in range(len(messages) - 1, -1, -1):
+        response = messages[index]
+        if not isinstance(response, ModelResponse):
+            continue
+        receipt = (response.metadata or {}).get(_ANCHOR)
+        if (
+            isinstance(receipt, dict)
+            and response.usage.input_tokens > 0
+            and response.state == "complete"
+            and receipt.get("request_models") == sorted(names)
+            and receipt.get("prefix") == fingerprint(messages[:index])
+            and receipt.get("response") == fingerprint([response])
+            and isinstance(receipt.get("overhead"), (int, float))
+        ):
+            replay = (
+                response.usage.output_tokens
+                if response.parts
+                and all(isinstance(p, TextPart) for p in response.parts)
+                and response.usage.output_tokens > 0
+                else estimate_tokens_for_message(response, response.model_name)
+            )
+            return (
+                response.usage.input_tokens
+                + replay
+                + context_overhead
+                - receipt["overhead"]
+                + sum(
+                    estimate_tokens_for_message(m, estimate_model)
+                    for m in messages[index + 1 :]
+                )
+            )
+        break
+    return context_overhead + sum(
+        estimate_tokens_for_message(m, estimate_model) for m in messages
+    )
+
+
+def active_model_name(agent):
+    """Use the request model identity, not an arbitrary config alias."""
+    model = getattr(agent, "cur_model", None)
+    if model is None:
+        model = getattr(getattr(agent, "pydantic_agent", None), "model", None)
+    return model_names(model) if model is not None else agent.get_model_name()
+
+
+def model_names(model):
+    """Identify a request model together with its routing candidates."""
+    candidates = getattr(model, "models", ())
+    if candidates:
+        return frozenset({model.model_name, *(m.model_name for m in candidates)})
+    return model.model_name

{code_puppy-0.0.910 → code_puppy-0.0.911}/code_puppy/model_switching.py

@@ -85,8 +85,11 @@ def _refresh_context_status(agent) -> None:
     try:
         capacity = agent._get_model_context_length()
         history = agent.get_message_history() or []
-        message_tokens = sum(agent.estimate_tokens_for_message(msg) for msg in history)
-        total_tokens = message_tokens + agent._estimate_context_overhead()
+        from code_puppy.context_accounting import active_model_name, context_tokens
+
+        total_tokens = context_tokens(
+            history, active_model_name(agent), agent._estimate_context_overhead()
+        )
         proportion = total_tokens / capacity if capacity else 0.0
         update_spinner_context(format_context_info(total_tokens, capacity, proportion))
     except Exception:

{code_puppy-0.0.910 → code_puppy-0.0.911}/code_puppy/plugins/__init__.py

@@ -190,6 +190,15 @@ def _load_installed_plugins() -> list[str]:
     )
     for entry_point in discovered:
         plugin_name = entry_point.name
+        if plugin_name == "token_ratio_learner":
+            # Retired: context accounting now anchors to the API's own
+            # reported prompt-token usage (see code_puppy.context_accounting)
+            # instead of a learned chars-per-token ratio. Older installed
+            # core-plugins bundles may still advertise this entry point for
+            # a while; skip it unconditionally rather than let a dead
+            # learner monkeypatch the shared fallback estimator.
+            logger.debug("Skipping retired plugin %s", plugin_name)
+            continue
         try:
             with _plugin_loading_context(plugin_name):
                 entry_point.load()

{code_puppy-0.0.910 → code_puppy-0.0.911}/code_puppy/token_usage.py

@@ -3,36 +3,37 @@
 Kept separate from ``register_callbacks.py`` so this stays unit-testable in
 isolation and so callbacks file remains thin.
 
-Design note — *why* we re-implement the token counting locally:
-
-``/context`` is supposed to be a *consistent*, model-agnostic view of how
-full the context window is. The core runtime has two layers that make
-token counts vary between models:
-
-1. The ``token_ratio_learner`` plugin monkeypatches
-   ``_history.estimate_tokens`` to use *learned* chars-per-token ratios
-   per model. Great for compaction decisions — terrible for a
-   user-facing dashboard, because the same conversation reports
-   different token counts on different models.
-
-2. ``_history._apply_multiplier`` bumps some models (e.g. Opus 4.7 by
-   1.35×) to compensate for tokenizers that over-tokenize relative to
-   our heuristic. Again: useful for safety margins, lousy for
-   "consistency between models".
-
-To keep ``/context`` honest and stable across model switches, this
-module uses its OWN raw ``max(1, floor(len(text) / 2.5))`` estimator
-and applies NO multiplier. Other parts of the system (compaction,
-summarization triggers) still use the calibrated values — that's
-intentional.
+Design note — why the aggregate total is anchored, not independently estimated:
+
+``/context`` used to compute its own ``max(1, floor(len(text) / 2.5))``
+estimate over the whole history, deliberately kept separate from
+compaction's calibrated estimator so the two heuristics couldn't disagree
+in confusing ways. But two heuristics measuring the same conversation can
+still drift from each other *and* from what the provider actually billed
+-- especially once caching is involved (Anthropic cache read/write, OpenAI
+cached tokens) -- and neither was the ground truth.
+
+``code_puppy.context_accounting.context_tokens`` anchors the total to the
+latest completed response's own API-reported prompt-token count and only
+estimates the delta since then, falling back to a plain per-message
+estimate when there's no valid anchor (first request, a rewritten prefix,
+a model switch, or a failed/cancelled request). Compaction, the status bar,
+and this module's aggregate total now share that one function, so they
+can't disagree with each other -- and the number agrees with the account
+you're actually billed on.
+
+The per-bucket overhead breakdown below (system prompt, AGENTS.md, tool
+schemas, MCP, kennel memory) stays a separate, deliberately raw heuristic:
+it has no corresponding per-bucket figure in the API response to anchor
+to, so it remains an estimate, not a billed-token partition.
 """
 
 from __future__ import annotations
 
 import json
 import math
-from dataclasses import dataclass
-from typing import Any, List, Optional
+from dataclasses import dataclass, field
+from typing import Any, List, Optional, cast
 
 __all__ = [
     "ContextUsage",
@@ -56,8 +57,8 @@ GREEN_CIRCLE = "🟢"
 YELLOW_CIRCLE = "🟡"
 RED_CIRCLE = "🔴"
 
-# Classic char/token heuristic, kept private so /context's numbers don't drift
-# if the core estimator is patched at runtime (token_ratio_learner plugin).
+# Model-agnostic heuristic for approximate /context overhead buckets.
+# Aggregate totals use shared accounting rather than these raw estimates.
 _CHARS_PER_TOKEN = 2.5
 
 
@@ -68,6 +69,18 @@ class ContextUsage:
     ``overhead_tokens`` is the *sum* of the per-bucket breakdown fields. The
     breakdown fields are optional (default 0) so legacy call sites that only
     care about the aggregate keep working without changes.
+
+    ``total_tokens`` is the authoritative aggregate -- the same number
+    compaction used to decide whether to trim. It is intentionally *not*
+    derived from ``used_tokens + overhead_tokens``: the overhead breakdown
+    is an independent, approximate re-estimate (e.g. it re-queries live MCP
+    tool schemas rather than the agent's cached server list), so it can be
+    larger *or* smaller than the shared total. Deriving the displayed total
+    from the breakdown would let an approximate bucket sum silently
+    override the number compaction actually decided against. Pass the real
+    total explicitly via the private ``_total_tokens`` constructor field;
+    when omitted (legacy/test call sites), it falls back to
+    ``used_tokens + overhead_tokens`` so existing behavior is unchanged.
     """
 
     used_tokens: int
@@ -79,10 +92,17 @@ class ContextUsage:
     pydantic_tools_tokens: int = 0
     mcp_tokens: int = 0
     kennel_memory_tokens: int = 0
+    _total_tokens: Optional[int] = field(default=None, repr=False)
+
+    def __post_init__(self) -> None:
+        if self._total_tokens is None:
+            object.__setattr__(
+                self, "_total_tokens", self.used_tokens + self.overhead_tokens
+            )
 
     @property
     def total_tokens(self) -> int:
-        return self.used_tokens + self.overhead_tokens
+        return cast(int, self._total_tokens)  # always set in __post_init__
 
     @property
     def proportion(self) -> float:
@@ -114,28 +134,15 @@ def pick_indicator(proportion: float) -> str:
 def _raw_estimate_tokens(text: str) -> int:
     """Pure char/2.5 heuristic. Identical for every model, every time.
 
-    Mirrors the *original* ``_history.estimate_tokens`` before any plugin
-    patches it. We deliberately don't import it — the whole point of this
-    function is to stay immune to the token_ratio_learner monkeypatch.
+    Keeps detailed overhead buckets model-agnostic and independent of
+    calibrated message estimates. The authoritative aggregate is computed
+    separately through shared context accounting.
     """
     if not text:
         return 0
     return max(1, math.floor(len(text) / _CHARS_PER_TOKEN))
 
 
-def _raw_tokens_for_message(message: Any) -> int:
-    """Sum raw tokens across a message's parts via the canonical stringifier."""
-    # ``stringify_part`` is a pure formatter — safe to import directly.
-    from code_puppy.agents._history import stringify_part
-
-    total = 0
-    for part in getattr(message, "parts", []) or []:
-        part_str = stringify_part(part)
-        if part_str:
-            total += _raw_estimate_tokens(part_str)
-    return total
-
-
 def _raw_tokens_for_pydantic_tools(tools: Optional[dict]) -> int:
     """Estimate tokens contributed by pydantic-ai registered tools.
 
@@ -370,11 +377,12 @@ def get_current_usage() -> Optional[ContextUsage]:
     Returns ``None`` whenever any required piece of data is unavailable —
     missing agent, missing model config, or *any* exception while estimating
     history/overhead/capacity. We deliberately do **not** fall back to
-    zero on partial failures: a misleading 🟢 indicator is worse than no
+    zero on partial failures: a misleading green indicator is worse than no
     indicator at all (the prompt simply hides the badge).
 
-    All token counts are computed with the raw model-agnostic heuristic
-    so the badge stays stable when the user switches models mid-session.
+    Aggregate counting shares compaction's API anchor and fallback estimator
+    (see the module docstring). Detailed overhead buckets below are
+    estimates, not a billed-token partition.
     """
     try:
         from code_puppy.agents.agent_manager import get_current_agent
@@ -390,7 +398,6 @@ def get_current_usage() -> Optional[ContextUsage]:
 
     try:
         history = agent.get_message_history() or []
-        used = sum(_raw_tokens_for_message(m) for m in history)
         capacity = agent._get_model_context_length()
     except Exception:
         return None
@@ -403,8 +410,16 @@ def get_current_usage() -> Optional[ContextUsage]:
     except Exception:
         return None
 
+    try:
+        from code_puppy.context_accounting import active_model_name, context_tokens
+
+        overhead = agent._estimate_context_overhead()
+        total = context_tokens(history, active_model_name(agent), overhead)
+    except Exception:
+        return None
+
     return ContextUsage(
-        used_tokens=int(used),
+        used_tokens=max(0, int(total) - breakdown.total),
         overhead_tokens=breakdown.total,
         capacity=int(capacity),
         system_prompt_tokens=breakdown.system_prompt_tokens,
@@ -412,4 +427,8 @@ def get_current_usage() -> Optional[ContextUsage]:
         pydantic_tools_tokens=breakdown.pydantic_tools_tokens,
         mcp_tokens=breakdown.mcp_tokens,
         kennel_memory_tokens=breakdown.kennel_memory_tokens,
+        # Authoritative: must equal compaction's decision total exactly,
+        # even when the (approximate, independently-estimated) overhead
+        # breakdown is larger than it -- see ContextUsage's docstring.
+        _total_tokens=int(total),
     )

{code_puppy-0.0.910 → code_puppy-0.0.911}/code_puppy/tools/subagent_invocation.py

@@ -488,7 +488,7 @@ async def _invoke_agent_impl(
                 # pydantic-ai v2).
                 capabilities=[
                     HistoryCompaction(agent_config),
-                    build_model_message_transform(agent_name),
+                    build_model_message_transform(agent_name, agent_config),
                     # Recursion guards ride the wrap_tool_execute seam so a
                     # sub-agent's own invoke_agent calls are denied before
                     # the tool body runs. Sole wrap_tool_execute implementer,