agentshim 0.21.0__tar.gz → 0.22.0__tar.gz

{agentshim-0.21.0 → agentshim-0.22.0}/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 0.22.0 (2026-10-19)
+
+### Fixed
+
+- A Claude turn's cost is priced from the per-model token counts in the CLI's `modelUsage` and
+  agentshim's own price table, not taken from the CLI's `total_cost_usd`. A Claude Code build older
+  than the model it runs does not know the model and bills it at a fallback rate (Claude Code
+  2.1.268 priced `claude-sonnet-5-5` about 2.6 times too high). `modelUsage` is cumulative over the
+  process, so a long-lived `ClaudeStreamTransport` prices each turn by the difference. A turn that
+  used a model with no table price has `cost_usd=None`; no price is guessed. Only a result with no
+  `modelUsage` keeps the CLI's figure.
+
+### Added
+
+- `CostSource` (`PRICE_TABLE`, `PROVIDER_REPORTED`, `UNKNOWN_MODEL`) and
+  `ProviderUsage.cost_source` say where `total_cost_usd` came from; `None` when no cost was
+  reported. The Codex app-server transport reports `PRICE_TABLE`. `to_dict()` gains `cost_source`.
+- `ClaudeStreamParser` takes `model_usage_baseline` and `pricing`, and exposes
+  `model_usage_total` for the next turn's baseline.
+
+## 0.21.1 (2026-10-19)
+
+### Fixed
+
+- Claude Sonnet 5.5, Claude Haiku 5.5, Claude Opus 4.7 and Claude Opus 4.6 have prices, so
+  `price_for` and cost lookups no longer come back empty for them. Haiku 5.5 carries its
+  prompts-up-to-100,000-tokens prices; its higher over-100,000-token prices are in the entry
+  `note`. Every Claude model in `default_models()` now has a price (tested).
+
 ## 0.21.0 (2026-10-18)
 
 ### Added

{agentshim-0.21.0 → agentshim-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentshim
-Version: 0.21.0
+Version: 0.22.0
 Summary: Provider-agnostic coding-agent CLI shims
 License-Expression: MIT
 License-File: LICENSE

{agentshim-0.21.0 → agentshim-0.22.0}/agentshim/__init__.py

@@ -36,6 +36,7 @@ from .core import (
     ContinuityError,
     Conversation,
     ConversationSpec,
+    CostSource,
     CredentialKind,
     CredentialSource,
     EndpointSpec,
@@ -185,7 +186,7 @@ from .providers.opencode import OpencodeProvider
 from .runtime import Agent
 from .session import Session, Turn, TurnTicket, map_mcp_servers
 
-__version__ = "0.21.0"
+__version__ = "0.22.0"
 
 __all__ = [  # noqa: RUF022 - public API test uses Python's case-sensitive order
     "Agent",
@@ -234,6 +235,7 @@ __all__ = [  # noqa: RUF022 - public API test uses Python's case-sensitive order
     "Conversation",
     "ConversationSpec",
     "CopilotProvider",
+    "CostSource",
     "CredentialKind",
     "CredentialSource",
     "DEFAULT_CATALOG",

{agentshim-0.21.0 → agentshim-0.22.0}/agentshim/core/__init__.py

@@ -126,7 +126,7 @@ from .skills import SkillSummary, SkillTracker
 from .status import AuthState, ProviderStatus
 from .stream import ToolTracker, parse_json_object
 from .turn import OutputSchema, TurnRequest, TurnResult
-from .usage import ProviderUsage, TokenUsage, TokenWeights, normalized_usage
+from .usage import CostSource, ProviderUsage, TokenUsage, TokenWeights, normalized_usage
 
 __all__ = [
     "AgentEvent",
@@ -157,6 +157,7 @@ __all__ = [
     "ContinuityError",
     "Conversation",
     "ConversationSpec",
+    "CostSource",
     "CredentialKind",
     "CredentialSource",
     "EndpointSpec",

{agentshim-0.21.0 → agentshim-0.22.0}/agentshim/core/usage.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 
 import math
 from dataclasses import dataclass, field
+from enum import Enum
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
@@ -261,6 +262,17 @@ def normalized_usage(  # noqa: PLR0913 - one keyword per normalized count
     )
 
 
+class CostSource(str, Enum):
+    """Where a reported cost came from."""
+
+    #: Computed from the turn's token counts and agentshim's price table.
+    PRICE_TABLE = "price_table"
+    #: The CLI's own figure, used only when it did not say which model ran.
+    PROVIDER_REPORTED = "provider_reported"
+    #: The turn used a model agentshim has no price for, so there is no cost.
+    UNKNOWN_MODEL = "unknown_model"
+
+
 @dataclass(frozen=True)
 class ProviderUsage:
     """Normalized token counts plus the raw provider mapping.
@@ -278,6 +290,9 @@ class ProviderUsage:
     provider: str = ""
     raw: Mapping[str, Any] | None = None
     increment_known: bool = True
+    #: Where ``total_cost_usd`` came from; ``None`` when no cost was reported.
+    #: ``UNKNOWN_MODEL`` goes with a ``None`` cost: no price is guessed.
+    cost_source: CostSource | None = None
 
     def to_dict(self) -> dict[str, Any]:
         """Flatten the normalized counts, cost, and provider name into one mapping.
@@ -290,4 +305,5 @@ class ProviderUsage:
             "total_cost_usd": self.total_cost_usd,
             "provider": self.provider,
             "increment_known": self.increment_known,
+            "cost_source": None if self.cost_source is None else self.cost_source.value,
         }

{agentshim-0.21.0 → agentshim-0.22.0}/agentshim/pricing.py

@@ -106,4 +106,4 @@ def default_pricing(*, catalog: ProviderCatalog | None = None) -> PricingTable:
             by_key[entry.key] = entry
     entries = tuple(by_key.values())
     updated = max((entry.checked for entry in entries), default=dt.date(2026, 9, 27))
-    return PricingTable(version="2026-09-27", last_updated=updated, entries=entries)
+    return PricingTable(version="2026-10-19", last_updated=updated, entries=entries)

agentshim-0.22.0/agentshim/providers/claude/cost.py

@@ -0,0 +1,140 @@
+"""Price a Claude turn from the CLI's per-model token counts.
+
+The CLI's own ``total_cost_usd`` is priced by the CLI's built-in table. A CLI
+older than the model it runs does not know the model and bills it at a
+fallback rate, so that figure can be several times too high. The ``modelUsage``
+mapping of a ``result`` frame carries the token counts per model, which
+agentshim prices with its own table instead.
+
+``modelUsage`` is cumulative over the CLI process, like ``total_cost_usd``, so
+a turn's tokens are the difference from the previous result's counts. It does
+not split cache writes by TTL; the turn's ``usage.cache_creation`` does, and
+its share of one-hour writes is applied to every model's writes.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, cast
+
+from agentshim.core.pricing import cost_usd
+from agentshim.core.usage import CostSource, TokenUsage, normalized_usage
+from agentshim.pricing import price_for
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from agentshim.core.pricing import PricingTable
+
+PROVIDER_NAME = "claude"
+
+
+@dataclass(frozen=True)
+class ModelCounts:
+    """One model's cumulative token counts as ``modelUsage`` reports them.
+
+    ``input_tokens`` is uncached input, disjoint from the cache counts, as in
+    the CLI's own report.
+    """
+
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_read_tokens: int = 0
+    cache_write_tokens: int = 0
+    #: The id the CLI says the model canonically is, when it says so.
+    canonical: str | None = None
+
+    def since(self, baseline: ModelCounts | None) -> ModelCounts:
+        """The counts accrued after *baseline*; a count that went down reads as 0."""
+        if baseline is None:
+            return self
+        return ModelCounts(
+            input_tokens=max(self.input_tokens - baseline.input_tokens, 0),
+            output_tokens=max(self.output_tokens - baseline.output_tokens, 0),
+            cache_read_tokens=max(self.cache_read_tokens - baseline.cache_read_tokens, 0),
+            cache_write_tokens=max(self.cache_write_tokens - baseline.cache_write_tokens, 0),
+            canonical=self.canonical,
+        )
+
+    @property
+    def empty(self) -> bool:
+        """Whether no token was counted."""
+        return not (
+            self.input_tokens
+            or self.output_tokens
+            or self.cache_read_tokens
+            or self.cache_write_tokens
+        )
+
+
+@dataclass(frozen=True)
+class TurnCost:
+    """A turn's cost and where it came from; ``usd`` is ``None`` for an unknown model."""
+
+    usd: float | None
+    source: CostSource
+
+
+def parse_model_usage(raw: object) -> dict[str, ModelCounts] | None:
+    """Read a ``result`` frame's ``modelUsage``; ``None`` when it is absent or malformed."""
+    if not isinstance(raw, dict):
+        return None
+    parsed: dict[str, ModelCounts] = {}
+    for model, counts in cast("dict[object, object]", raw).items():
+        if not isinstance(model, str) or not isinstance(counts, dict):
+            return None
+        fields = cast("Mapping[str, Any]", counts)
+        canonical = fields.get("canonicalModel")
+        parsed[model] = ModelCounts(
+            input_tokens=_count(fields, "inputTokens"),
+            output_tokens=_count(fields, "outputTokens"),
+            cache_read_tokens=_count(fields, "cacheReadInputTokens"),
+            cache_write_tokens=_count(fields, "cacheCreationInputTokens"),
+            canonical=canonical if isinstance(canonical, str) else None,
+        )
+    return parsed
+
+
+def priced_turn(
+    model_usage: Mapping[str, ModelCounts],
+    baseline: Mapping[str, ModelCounts],
+    *,
+    one_hour_share: float,
+    table: PricingTable | None = None,
+) -> TurnCost:
+    """Price one turn's tokens, each model at its own table price.
+
+    *one_hour_share* is the fraction of cache writes billed at the one-hour
+    rate. A model with tokens in the turn and no price makes the whole turn
+    ``UNKNOWN_MODEL`` with no cost: a partial sum would read as complete.
+    """
+    total = 0.0
+    for model, counts in model_usage.items():
+        delta = counts.since(baseline.get(model))
+        if delta.empty:
+            continue
+        pricing = price_for(PROVIDER_NAME, model, table)
+        if pricing is None and delta.canonical is not None:
+            pricing = price_for(PROVIDER_NAME, delta.canonical, table)
+        if pricing is None:
+            return TurnCost(None, CostSource.UNKNOWN_MODEL)
+        total += cost_usd(_tokens(delta, one_hour_share), pricing)
+    return TurnCost(total, CostSource.PRICE_TABLE)
+
+
+def _tokens(counts: ModelCounts, one_hour_share: float) -> TokenUsage:
+    share = min(max(one_hour_share, 0.0), 1.0)
+    return normalized_usage(
+        input_tokens=counts.input_tokens + counts.cache_read_tokens + counts.cache_write_tokens,
+        output_tokens=counts.output_tokens,
+        cache_read_input_tokens=counts.cache_read_tokens,
+        cache_write_input_tokens=counts.cache_write_tokens,
+        cache_write_1h_input_tokens=round(counts.cache_write_tokens * share),
+    )
+
+
+def _count(counts: Mapping[str, Any], key: str) -> int:
+    value = counts.get(key)
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return 0
+    return max(int(value), 0)

{agentshim-0.21.0 → agentshim-0.22.0}/agentshim/providers/claude/events.py

@@ -10,6 +10,7 @@ import json
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, cast
 
+from .cost import ModelCounts, parse_model_usage
 from .rate_limits import RateLimitFrame, parse_rate_limit
 
 if TYPE_CHECKING:
@@ -86,6 +87,8 @@ class ResultFrame:
     num_turns: int | None = None
     usage: Mapping[str, Any] | None = None
     total_cost_usd: float | None = None
+    #: Per-model cumulative token counts (the CLI's ``modelUsage``); ``None`` when absent.
+    model_usage: Mapping[str, ModelCounts] | None = None
     duration_ms: int | None = None
     is_error: bool = False
     subtype: str | None = None
@@ -126,6 +129,7 @@ def parse_frame(data: Mapping[str, Any]) -> ClaudeFrame | None:
             num_turns=_int_or_none(data.get("num_turns")),
             usage=_mapping_or_none(data.get("usage")),
             total_cost_usd=_float_or_none(data.get("total_cost_usd")),
+            model_usage=parse_model_usage(data.get("modelUsage")),
             duration_ms=_int_or_none(data.get("duration_ms")),
             is_error=bool(data.get("is_error")),
             subtype=_str_or_none(data.get("subtype")),

{agentshim-0.21.0 → agentshim-0.22.0}/agentshim/providers/claude/model_data.py

@@ -10,7 +10,7 @@ ANTHROPIC_CONTEXT_WINDOWS_URL = (
 )
 ANTHROPIC_PRICING_URL = "https://platform.claude.com/docs/en/about-claude/pricing"
 _MODEL_CHECKED = dt.date(2026, 10, 17)
-_PRICE_CHECKED = dt.date(2026, 9, 27)
+_PRICE_CHECKED = dt.date(2026, 10, 19)
 
 
 def _anthropic_model(
@@ -61,6 +61,9 @@ MODEL_ENTRIES = (
 )
 
 
+_NOTE = "Claude API first-party, global inference; thinking is billed as output."
+
+
 def _anthropic(  # noqa: PLR0913 - one positional per price column
     model: str,
     input_usd: float,
@@ -68,6 +71,7 @@ def _anthropic(  # noqa: PLR0913 - one positional per price column
     cache_write_1h_usd: float,
     cache_read_usd: float,
     output_usd: float,
+    note: str = "",
 ) -> ModelPricing:
     return ModelPricing(
         vendor="anthropic",
@@ -79,7 +83,7 @@ def _anthropic(  # noqa: PLR0913 - one positional per price column
         output_usd=output_usd,
         source=ANTHROPIC_PRICING_URL,
         checked=_PRICE_CHECKED,
-        note="Claude API first-party, global inference; thinking is billed as output.",
+        note=f"{_NOTE} {note}".strip(),
     )
 
 
@@ -89,7 +93,23 @@ PRICING_ENTRIES = (
     _anthropic("claude-opus-5-5", 4.00, 5.00, 8.00, 0.20, 20.00),
     _anthropic("claude-opus-5", 5.00, 6.25, 10.00, 0.50, 25.00),
     _anthropic("claude-opus-4-8", 5.00, 6.25, 10.00, 0.50, 25.00),
+    _anthropic("claude-opus-4-7", 5.00, 6.25, 10.00, 0.50, 25.00),
+    _anthropic("claude-opus-4-6", 5.00, 6.25, 10.00, 0.50, 25.00),
+    _anthropic("claude-sonnet-5-5", 2.00, 2.50, 4.00, 0.10, 10.00),
     _anthropic("claude-sonnet-5", 2.00, 2.50, 4.00, 0.20, 10.00),
     _anthropic("claude-sonnet-4-6", 3.00, 3.75, 6.00, 0.30, 15.00),
+    _anthropic(
+        "claude-haiku-5-5",
+        0.10,
+        0.125,
+        0.20,
+        0.01,
+        0.50,
+        note=(
+            "Prices for prompts up to 100,000 tokens; a request whose prompt is over "
+            "100,000 tokens pays 0.50 input, 0.625 cache write, 1.00 1h cache write, "
+            "0.05 cache read and 2.50 output, which this table leaves out."
+        ),
+    ),
     _anthropic("claude-haiku-4-5", 1.00, 1.25, 2.00, 0.10, 5.00),
 )

{agentshim-0.21.0 → agentshim-0.22.0}/agentshim/providers/claude/parser.py

@@ -21,8 +21,9 @@ from agentshim.core.events import (
 )
 from agentshim.core.provider import ParsedTurn
 from agentshim.core.stream import ToolTracker, parse_json_object
-from agentshim.core.usage import ProviderUsage, TokenUsage, normalized_usage
+from agentshim.core.usage import CostSource, ProviderUsage, TokenUsage, normalized_usage
 
+from .cost import ModelCounts, priced_turn
 from .events import (
     AssistantMessage,
     ResultFrame,
@@ -40,6 +41,7 @@ if TYPE_CHECKING:
 
     from agentshim.core.errors import FailureKind
     from agentshim.core.events import AgentEvent
+    from agentshim.core.pricing import PricingTable
 
 PROVIDER_NAME = "claude"
 
@@ -128,6 +130,8 @@ class ClaudeStreamParser:
         *,
         expect_structured: bool = False,
         cost_baseline_usd: float = 0.0,
+        model_usage_baseline: Mapping[str, ModelCounts] | None = None,
+        pricing: PricingTable | None = None,
     ) -> None:
         """Start a parser for one run.
 
@@ -137,9 +141,20 @@ class ClaudeStreamParser:
         total its previous turn ended at as *cost_baseline_usd* and this
         parser reports the turn's own cost (``total_cost_usd`` then still
         holds the cumulative figure).
+
+        The turn's cost is priced from the result's ``modelUsage`` with the
+        agentshim price table (*pricing*, or the default one), never from the
+        CLI's ``total_cost_usd`` when the models are known. ``modelUsage`` is
+        cumulative too: pass the previous turn's ``model_usage_total`` as
+        *model_usage_baseline*. Only a result without ``modelUsage`` falls
+        back to the CLI's figure.
         """
         self._cost_baseline = cost_baseline_usd
+        self._model_usage_baseline: Mapping[str, ModelCounts] = model_usage_baseline or {}
+        self._pricing = pricing
         self.total_cost_usd: float | None = None
+        #: The cumulative per-model counts the last result reported.
+        self.model_usage_total: Mapping[str, ModelCounts] | None = None
         self._emit = emit
         self._expect_structured = expect_structured
         self._tools = ToolTracker()
@@ -150,6 +165,7 @@ class ClaudeStreamParser:
         self._usage = ProviderUsage(provider=PROVIDER_NAME)
         self._results = 0
         self._cost_usd: float | None = None
+        self._cost_source: CostSource | None = None
         self._error: str | None = None
         # What the stream said about a failed API request, for classifying it.
         self._api_error: str | None = None
@@ -278,11 +294,9 @@ class ClaudeStreamParser:
     def _result(self, frame: ResultFrame) -> None:
         self._final_text = frame.text
         self.total_cost_usd = frame.total_cost_usd
-        self._cost_usd = (
-            None if frame.total_cost_usd is None else frame.total_cost_usd - self._cost_baseline
-        )
-        self._structured = self._structured_payload(frame)
         tokens = fold_usage(frame.usage, turns=frame.num_turns or 0)
+        self._price(frame, tokens)
+        self._structured = self._structured_payload(frame)
         if self._results:
             # A steered message can start a follow-on turn inside this run; its
             # ``result`` reports only its own tokens, so the run sums them.
@@ -293,6 +307,7 @@ class ClaudeStreamParser:
             total_cost_usd=self._cost_usd,
             provider=PROVIDER_NAME,
             raw=frame.usage,
+            cost_source=self._cost_source,
         )
         self._emit(UsageReport(self._usage, self._cost_usd))
         if frame.is_error:
@@ -301,6 +316,27 @@ class ClaudeStreamParser:
             self._error = self._error_text(frame)
             self._emit(ProviderError(self._error))
 
+    def _price(self, frame: ResultFrame, tokens: TokenUsage) -> None:
+        """Set the turn's cost from its per-model tokens, or from the CLI's when it names none."""
+        if frame.model_usage is not None:
+            self.model_usage_total = frame.model_usage
+            writes = tokens.cache_write_input_tokens
+            share = tokens.cache_write_1h_input_tokens / writes if writes else 0.0
+            priced = priced_turn(
+                frame.model_usage,
+                self._model_usage_baseline,
+                one_hour_share=share,
+                table=self._pricing,
+            )
+            self._cost_usd = priced.usd
+            self._cost_source = priced.source
+        elif frame.total_cost_usd is not None:
+            self._cost_usd = frame.total_cost_usd - self._cost_baseline
+            self._cost_source = CostSource.PROVIDER_REPORTED
+        else:
+            self._cost_usd = None
+            self._cost_source = None
+
     def _structured_payload(self, frame: ResultFrame) -> object | None:
         # Only a turn that asked for a schema gets a payload: an unrequested
         # ``structured_output`` field must never replace the prose answer.

{agentshim-0.21.0 → agentshim-0.22.0}/agentshim/providers/claude/stream_transport.py

@@ -10,8 +10,9 @@ in ``tests/fixtures/claude_stream``):
 
 * ``system/init`` is repeated at the start of every turn, so readiness is the
   reply to the ``initialize`` request, not ``init``.
-* ``total_cost_usd`` is cumulative over the process while ``usage`` is per turn,
-  so the cost of a turn is the difference from the previous result.
+* ``total_cost_usd`` and ``modelUsage`` are cumulative over the process while
+  ``usage`` is per turn, so the cost of a turn is the difference from the
+  previous result. The cost is priced from ``modelUsage`` (see ``cost.py``).
 * A failed API request arrives as a ``result`` with subtype ``success`` and
   ``is_error`` true; a failure is classified on ``is_error`` first.
 * ``--json-schema``, MCP servers, effort and extra arguments are flags of the
@@ -99,6 +100,7 @@ if TYPE_CHECKING:
     from agentshim.execution.executor import CommandExecutor
     from agentshim.execution.process import Process, ProcessOutput
 
+    from .cost import ModelCounts
     from .user_hooks import ClaudeHook
 
 #: How often an idle pull loop looks at the clock again.
@@ -288,6 +290,7 @@ class _StreamConversation:
         self._argv: tuple[str, ...] = ()
         self._config = ProcessConfig()
         self._cost_baseline = 0.0
+        self._model_usage_baseline: Mapping[str, ModelCounts] = {}
         self._stderr_tail: deque[str] = _lines()
         self._closed = False
         self._running = False
@@ -414,6 +417,7 @@ class _StreamConversation:
             relay,
             expect_structured=request.output_schema is not None,
             cost_baseline_usd=self._cost_baseline,
+            model_usage_baseline=self._model_usage_baseline,
         )
         deadline = None if request.timeout is None else started + request.timeout
         run = _TurnRun(parser, relay, request.timeout, deadline)
@@ -502,6 +506,7 @@ class _StreamConversation:
                 self._argv = tuple(argv)
                 self._config = config
                 self._cost_baseline = 0.0
+                self._model_usage_baseline = {}
         if closed:
             self._stop(process)  # outside the lock: a stop waits, and interrupts need the lock
             msg = "conversation closed while its process started"
@@ -863,6 +868,8 @@ class _StreamConversation:
         parsed = parser.finish()
         if parser.total_cost_usd is not None:
             self._cost_baseline = parser.total_cost_usd
+        if parser.model_usage_total is not None:
+            self._model_usage_baseline = parser.model_usage_total
         self._learn_id(parsed.session_id)
         self._report_denials(run, frame)
         if run.expired:

{agentshim-0.21.0 → agentshim-0.22.0}/agentshim/providers/codex/app_server/transport.py

@@ -51,6 +51,7 @@ from agentshim.core.permissions import ApprovalPolicy
 from agentshim.core.schema import dialect_problems
 from agentshim.core.skills import SkillTracker
 from agentshim.core.turn import TurnResult
+from agentshim.core.usage import CostSource
 from agentshim.execution.host import HostCommandExecutor
 from agentshim.execution.process import SpawnRequest
 from agentshim.pricing import cost_usd, price_for
@@ -927,7 +928,11 @@ class _Conversation:
         usage = turn_usage(turn.total, self._baseline)
         pricing = self._pricing
         if usage.increment_known and pricing is not None:
-            usage = replace(usage, total_cost_usd=cost_usd(usage.tokens, pricing))
+            usage = replace(
+                usage,
+                total_cost_usd=cost_usd(usage.tokens, pricing),
+                cost_source=CostSource.PRICE_TABLE,
+            )
         if turn.total is not None:
             self._baseline = turn.total
         return usage

{agentshim-0.21.0 → agentshim-0.22.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentshim"
-version = "0.21.0"
+version = "0.22.0"
 description = "Provider-agnostic coding-agent CLI shims"
 readme = "README.md"
 license = "MIT"