agentshim 0.22.0__tar.gz → 0.23.1__tar.gz

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

@@ -1,5 +1,54 @@
 # Changelog
 
+## 0.23.1 (2026-10-30)
+
+### Fixed
+
+- `gpt-6.1-sol` has a price. The catalogue listed it since 0.18.2 but the price table did not, so
+  `price_for("codex", "gpt-6.1-sol")` returned `None` and its turns recorded no cost. The rates are
+  the standard short-context tier on https://developers.openai.com/api/docs/pricing, read
+  2026-10-30: input 2.00, cache read 0.10, cache write 2.50, output 10.00 USD per million tokens.
+  The cache read rate is half of `gpt-6-sol`'s. The table version is `2026-10-30`.
+
+### Added
+
+- A test that every model the catalogue or a provider profile lists is priced or named, with its
+  reason, in an exclusion list. `gemini-3-pro-preview` is the one exclusion: Google's pricing page
+  no longer lists it, so no official number can be checked, and Gemini models are not priced.
+
+## 0.23.0 (2026-10-20)
+
+### Added
+
+- `FailureKind.CONTEXT_OVERFLOW`: the provider refused the turn because the conversation and the
+  new prompt do not fit the model's context window. Claude is read from the result frame's
+  `terminal_reason` (`prompt_too_long`, `blocking_limit`, `rapid_refill_breaker`), and from the
+  text `Prompt is too long` on builds without it; this wins over the 503 a failed compaction
+  appends, which used to make the overflow look `TRANSIENT`. Codex is read from the app-server's
+  `codexErrorInfo: contextWindowExceeded`, from the Responses API error body's `error.code`
+  `context_length_exceeded` (which the app-server relays under `other`, and `codex exec` as its
+  only report), and from Codex's "ran out of room in the model's context window". Before, every
+  one of these was `OTHER` or `TRANSIENT`. Gemini CLI 0.25.2 reports an overflow as a `success`
+  with zero tokens, so it cannot be classified; Copilot and opencode have no recorded overflow
+  and stay `OTHER`.
+- `TurnResult.context_tokens` (and `ParsedTurn.context_tokens`): how many tokens the
+  conversation's context holds after the turn, which is what the next resume starts from. It is
+  the turn's last model call, its whole prompt (uncached input, cache reads, cache writes) plus
+  its output, not the turn's summed `usage`. Claude: the last main-thread assistant frame's usage,
+  skipping subagent frames and the CLI's synthetic error messages; the output count on that frame
+  is taken when the reply starts, so it can undercount the final reply. Codex app-server:
+  `last.totalTokens` of the turn's last `thread/tokenUsage/updated`. opencode: the last
+  `step_finish`, without reasoning. `None` for `codex exec` (thread totals only), Gemini (one sum
+  per turn), Copilot (per-request usage is not printed), and a turn with no model call.
+- `FakeTurn(context_tokens=...)` scripts the reading in `agentshim.testing`.
+
+### Changed
+
+- A session forgets its conversation after a `CONTEXT_OVERFLOW`, whether or not the turn resumed
+  it, since the conversation cannot take another turn. Strict and pinned turns keep it.
+- `scripted_failure("codex", FailureKind.OTHER)` scripts a refused model; its old text was a
+  context overflow.
+
 ## 0.22.0 (2026-10-19)
 
 ### Fixed

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

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

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

@@ -186,7 +186,7 @@ from .providers.opencode import OpencodeProvider
 from .runtime import Agent
 from .session import Session, Turn, TurnTicket, map_mcp_servers
 
-__version__ = "0.22.0"
+__version__ = "0.23.1"
 
 __all__ = [  # noqa: RUF022 - public API test uses Python's case-sensitive order
     "Agent",

{agentshim-0.22.0 → agentshim-0.23.1}/agentshim/agent.py

@@ -415,6 +415,7 @@ class AgentSession:
             duration_ms=duration_ms,
             exit_code=result.returncode,
             skills=skills.summary(),
+            context_tokens=parsed.context_tokens,
         )
         self.last_result = turn_result
         return turn_result

{agentshim-0.22.0 → agentshim-0.23.1}/agentshim/core/errors.py

@@ -33,6 +33,11 @@ class FailureKind(str, Enum):
     #: schema. ``detail`` carries the last validation errors it reported, and
     #: the conversation survives: a correction can be sent as the next turn.
     SCHEMA = "schema"
+    #: The conversation plus the new prompt do not fit the model's context
+    #: window, so the provider refused the turn. Sending the same turn to the
+    #: same conversation fails again; a fresh conversation, or a shorter
+    #: prompt, is the way forward.
+    CONTEXT_OVERFLOW = "context_overflow"
     #: Anything else, including every failure a provider cannot classify.
     OTHER = "other"
 

{agentshim-0.22.0 → agentshim-0.23.1}/agentshim/core/provider.py

@@ -67,6 +67,9 @@ class ParsedTurn:
     error: str | None = None
     #: The parser's classification of ``error``; ``OTHER`` when it cannot tell.
     error_kind: FailureKind = FailureKind.OTHER
+    #: Tokens in the conversation's context after the turn; see
+    #: ``TurnResult.context_tokens``. ``None`` when the stream cannot say.
+    context_tokens: int | None = None
 
 
 class StreamParser(Protocol):

{agentshim-0.22.0 → agentshim-0.23.1}/agentshim/core/session_policy.py

@@ -16,6 +16,8 @@ What the policy decides, per turn:
   did not itself resume (the conversation was lost under it) forgets the
   conversation without replaying the turn.
 * An unclassified failure of a resumed turn forgets the conversation.
+* A context overflow forgets the conversation, resumed or not: it cannot take
+  another turn.
 * After a successful turn that exhausts the provider's ``RenewalBudget`` the
   conversation is retired.
 * An idle conversation is released at prepare time and reopened by id.
@@ -87,6 +89,8 @@ class Outcome(Enum):
     USAGE_LIMIT = "usage_limit"
     AUTH = "auth"
     SCHEMA = "schema"
+    #: The conversation no longer fits the model's context window.
+    CONTEXT_OVERFLOW = "context_overflow"
     #: A failure the provider could not classify.
     OTHER = "other"
     #: The provider no longer has the conversation the attempt tried to resume.
@@ -103,6 +107,7 @@ _OUTCOME_OF_KIND = {
     FailureKind.USAGE_LIMIT: Outcome.USAGE_LIMIT,
     FailureKind.AUTH: Outcome.AUTH,
     FailureKind.SCHEMA: Outcome.SCHEMA,
+    FailureKind.CONTEXT_OVERFLOW: Outcome.CONTEXT_OVERFLOW,
     FailureKind.OTHER: Outcome.OTHER,
 }
 
@@ -536,6 +541,8 @@ class SessionPolicy:
             return self._on_resume_refused(state, turn, event)
         if event.outcome is Outcome.OTHER and turn.resumed and not turn.keeps_conversation:
             return _forget_conversation(state, event.now)
+        if event.outcome is Outcome.CONTEXT_OVERFLOW and not turn.keeps_conversation:
+            return _forget_conversation(state, event.now)
         return _give_up(state, event.now)
 
     def _on_resume_refused(self, state: SessionState, turn: TurnState, event: Failed) -> Step:

{agentshim-0.22.0 → agentshim-0.23.1}/agentshim/core/turn.py

@@ -69,6 +69,15 @@ class TurnResult:
     #: The turn ended because it was interrupted. The conversation is kept; the
     #: text and usage are whatever the turn produced before it stopped.
     interrupted: bool = False
+    #: How many tokens the conversation's context holds after this turn: what
+    #: the next turn that resumes it starts from. It is the last model call of
+    #: the turn, counted as the prompt that call sent (uncached input, cache
+    #: reads and cache writes) plus the output it wrote, not ``usage``, which
+    #: sums every call of the turn and so counts the prompt once per call.
+    #: Calls made by a subagent are not this conversation's and are skipped.
+    #: Each provider's source is listed in ``docs/sessions.md``. ``None`` when
+    #: the provider does not report a single model call's usage.
+    context_tokens: int | None = None
 
 
 def coerce_request(request: TurnRequest | str) -> TurnRequest:

{agentshim-0.22.0 → agentshim-0.23.1}/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-10-19", last_updated=updated, entries=entries)
+    return PricingTable(version="2026-10-30", last_updated=updated, entries=entries)

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

@@ -67,6 +67,14 @@ class AssistantMessage:
     #: when a request fails (``overloaded``, ``rate_limit``, ...); ``None`` on
     #: a normal reply.
     error: str | None = None
+    #: The API message id; the frames of one model call share it.
+    message_id: str | None = None
+    #: The model that wrote the message: ``<synthetic>`` for a message the CLI
+    #: wrote itself (an error) rather than a model call.
+    model: str | None = None
+    #: The ``Task`` call whose subagent wrote this, or ``None`` for the main
+    #: conversation.
+    parent_tool_use_id: str | None = None
 
 
 @dataclass(frozen=True)
@@ -157,7 +165,14 @@ def _assistant(data: Mapping[str, Any]) -> AssistantMessage | None:
     error = _str_or_none(data.get("error"))
     if not blocks and usage is None and error is None:
         return None
-    return AssistantMessage(blocks=tuple(blocks), usage=usage, error=error)
+    return AssistantMessage(
+        blocks=tuple(blocks),
+        usage=usage,
+        error=error,
+        message_id=_str_or_none(payload.get("id")),
+        model=_str_or_none(payload.get("model")),
+        parent_tool_use_id=_str_or_none(data.get("parent_tool_use_id")),
+    )
 
 
 def _content_block(raw: object) -> ContentBlock | None:

{agentshim-0.22.0 → agentshim-0.23.1}/agentshim/providers/claude/failures.py

@@ -7,6 +7,11 @@ kind on the synthetic assistant message it writes for the failure, an
 have the text, so all three are read. A turn whose ``StructuredOutput`` calls
 never validated ends with the ``result`` subtype
 ``error_max_structured_output_retries`` instead.
+
+A prompt the context window cannot hold is named by the ``result`` frame's
+``terminal_reason``. Builds without that field write ``Prompt is too long``
+as the message, sometimes followed by why the CLI's own compaction failed
+(which can be an API 503), so the overflow is checked before the status.
 """
 
 from __future__ import annotations
@@ -43,22 +48,38 @@ _TRANSIENT_STATUSES = frozenset({408, 429})
 _SERVER_ERRORS = range(500, 600)
 #: The ``result`` subtype of a turn that used up its output-schema retries.
 SCHEMA_RETRIES_SUBTYPE = "error_max_structured_output_retries"
+#: ``terminal_reason`` values Claude Code groups as a context limit: the API
+#: refused the prompt, the CLI's own estimate was over its blocking limit, or
+#: the context refilled right after a compaction.
+CONTEXT_LIMIT_REASONS = frozenset({"prompt_too_long", "blocking_limit", "rapid_refill_breaker"})
+#: The CLI's message for the same, and the API's (``prompt is too long: N
+#: tokens > M maximum``), for builds that write no ``terminal_reason`` or a
+#: path that sets another one (a compaction that failed on its own error).
+_CONTEXT_LIMIT_TEXT = re.compile(r"\bprompt is too long\b", re.IGNORECASE)
 
 
 def classify_failure(
-    *, subtype: str | None, api_error: str | None, status: int | None, text: str
+    *,
+    subtype: str | None,
+    api_error: str | None,
+    status: int | None,
+    text: str,
+    terminal_reason: str | None = None,
 ) -> FailureKind:
     """Classify one failed turn from what Claude reported about it.
 
     ``subtype`` is the error ``result`` frame's subtype, ``api_error`` the
     assistant frame's ``error`` kind, ``status`` the
-    result frame's ``api_error_status``, and ``text`` the error text the
-    stream (or, when the stream had none, stderr) carried. Tool output is
-    never part of ``text``, so a tool that printed an API error cannot make
-    the turn look like one.
+    result frame's ``api_error_status``, ``text`` the error text the
+    stream (or, when the stream had none, stderr) carried, and
+    ``terminal_reason`` why the CLI said it stopped. Tool output is never part
+    of ``text``, so a tool that printed an API error cannot make the turn
+    look like one.
     """
     if subtype == SCHEMA_RETRIES_SUBTYPE:
         return FailureKind.SCHEMA
+    if terminal_reason in CONTEXT_LIMIT_REASONS or _CONTEXT_LIMIT_TEXT.search(text):
+        return FailureKind.CONTEXT_OVERFLOW
     return _classify_api_failure(api_error=api_error, status=status, text=text)
 
 

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

@@ -89,6 +89,28 @@ def fold_usage(usage: Mapping[str, Any] | None, turns: int = 0) -> TokenUsage:
     )
 
 
+#: The ``model`` of a message Claude Code wrote itself rather than a model.
+SYNTHETIC_MODEL = "<synthetic>"
+
+
+def context_tokens(usage: Mapping[str, Any]) -> int:
+    """Tokens one model call leaves in the context: its whole prompt plus its output.
+
+    The prompt is ``input_tokens`` (uncached) plus the cache reads and cache
+    writes, which Anthropic reports disjoint from it. The output count is the
+    one Claude Code writes on the message's frames. It is taken when the reply
+    starts, so it can fall short of the final reply by the tokens generated
+    after that; most of those are thinking, which the API drops from the
+    prompt of later turns anyway.
+    """
+    return (
+        _int(usage.get("input_tokens"))
+        + _int(usage.get("cache_read_input_tokens"))
+        + _int(usage.get("cache_creation_input_tokens"))
+        + _int(usage.get("output_tokens"))
+    )
+
+
 def _int(value: object) -> int:
     if isinstance(value, bool):
         return 0
@@ -172,9 +194,12 @@ class ClaudeStreamParser:
         self._api_error_text: str | None = None
         self._api_error_status: int | None = None
         self._subtype: str | None = None
+        self._terminal_reason: str | None = None
         # The validation errors of the last rejected StructuredOutput call.
         self._schema_errors: str | None = None
         self._stderr: list[str] = []
+        # The context the main conversation's last model call left.
+        self._context_tokens: int | None = None
 
     def feed_stdout(self, line: str) -> None:
         """Consume one stdout line, emitting the events its frame implies.
@@ -211,6 +236,7 @@ class ClaudeStreamParser:
             cost_usd=self._cost_usd,
             error=self._error,
             error_kind=self._error_kind(),
+            context_tokens=self._context_tokens,
         )
 
     def _error_kind(self) -> FailureKind:
@@ -226,6 +252,7 @@ class ClaudeStreamParser:
             api_error=self._api_error,
             status=self._api_error_status,
             text=text,
+            terminal_reason=self._terminal_reason,
         )
 
     def _handle(self, frame: object) -> None:
@@ -251,6 +278,12 @@ class ClaudeStreamParser:
             self._api_error_text = "\n".join(
                 block.text for block in frame.blocks if isinstance(block, TextBlock)
             )
+        if (
+            frame.usage is not None
+            and frame.parent_tool_use_id is None
+            and frame.model != SYNTHETIC_MODEL
+        ):
+            self._context_tokens = context_tokens(frame.usage)
         if frame.usage is not None:
             self._emit(
                 UsageReport(
@@ -313,6 +346,7 @@ class ClaudeStreamParser:
         if frame.is_error:
             self._api_error_status = frame.api_error_status
             self._subtype = frame.subtype
+            self._terminal_reason = frame.terminal_reason
             self._error = self._error_text(frame)
             self._emit(ProviderError(self._error))
 

{agentshim-0.22.0 → agentshim-0.23.1}/agentshim/providers/claude/scripted.py

@@ -129,8 +129,12 @@ _FAILURES: dict[FailureKind, tuple[str, int, str]] = {
     ),
     FailureKind.USAGE_LIMIT: ("rate_limit", 429, "You've hit your limit \u00b7 resets 3pm (UTC)"),
     FailureKind.AUTH: ("authentication_failed", 401, "Invalid API key \u00b7 Please run /login"),
+    FailureKind.CONTEXT_OVERFLOW: ("invalid_request", 400, "Prompt is too long"),
 }
 
+#: Why Claude Code says a turn of each kind stopped, where that is its signal.
+_TERMINAL_REASONS: dict[FailureKind, str] = {FailureKind.CONTEXT_OVERFLOW: "prompt_too_long"}
+
 #: The validation errors Claude's ``StructuredOutput`` tool returns for a
 #: submission that does not match the schema.
 SCHEMA_ERRORS = "Output does not match required schema: root: must have required property 'answer'"
@@ -170,6 +174,8 @@ def failure_lines(
         message = {"role": "assistant", "content": [{"type": "text", "text": text}]}
         lines.append(_line({"type": "assistant", "message": message, "error": error}))
         result.update(subtype="success", result=text, api_error_status=status)
+        if kind in _TERMINAL_REASONS:
+            result["terminal_reason"] = _TERMINAL_REASONS[kind]
     lines.append(_line(result))
     return lines, [], 1
 

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

@@ -436,6 +436,7 @@ class _StreamConversation:
             exit_code=0,
             skills=skills.summary(),
             interrupted=_interrupted(frame),
+            context_tokens=parsed.context_tokens,
         )
         if result.interrupted:
             relay(TurnInterrupted())

{agentshim-0.22.0 → agentshim-0.23.1}/agentshim/providers/codex/app_server/errors.py

@@ -9,6 +9,9 @@ source; when it says only ``other`` (it then carries the raw HTTP body in
   a lost connection or response stream (unless it ended in a client error
   other than 408 and 429): ``TRANSIENT``.
 - ``unauthorized``, or a connection failure with HTTP 401 or 403: ``AUTH``.
+- ``contextWindowExceeded``: ``CONTEXT_OVERFLOW``. A request the Responses API
+  refuses for its length arrives as ``other`` with the API's error body, and
+  the text classifier reads its ``context_length_exceeded`` code.
 - anything else: the text classifier, which returns ``OTHER`` for text it does
   not recognize.
 """
@@ -35,6 +38,7 @@ _BY_KIND: dict[CodexErrorInfoKind, FailureKind] = {
     CodexErrorInfoKind.INTERNAL_SERVER_ERROR: FailureKind.TRANSIENT,
     CodexErrorInfoKind.FLEX_UNAVAILABLE: FailureKind.TRANSIENT,
     CodexErrorInfoKind.UNAUTHORIZED: FailureKind.AUTH,
+    CodexErrorInfoKind.CONTEXT_WINDOW_EXCEEDED: FailureKind.CONTEXT_OVERFLOW,
 }
 
 _AUTH_STATUSES = frozenset({401, 403})

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

@@ -318,6 +318,9 @@ class _Turn:
     turn_id: str | None = None
     items: list[ThreadItem] = field(default_factory=_no_items)
     total: Totals | None = None
+    #: ``last.totalTokens`` of the turn's latest usage report: the context
+    #: its last model call left.
+    context_tokens: int | None = None
     completed: Turn | None = None
     error: TurnError | None = None
     fail: TurnFailedError | None = None
@@ -752,6 +755,7 @@ class _Conversation:
         elif isinstance(params, ThreadTokenUsageUpdatedNotification):
             if self._is_mine(params.thread_id, params.turn_id, turn):
                 turn.total = totals_of(params.token_usage.total)
+                turn.context_tokens = params.token_usage.last.total_tokens
         elif isinstance(params, ErrorNotification):
             self._on_error(params, turn)
         elif isinstance(params, TurnCompletedNotification):
@@ -909,6 +913,7 @@ class _Conversation:
             duration_ms=duration_ms,
             exit_code=0,
             interrupted=interrupted,
+            context_tokens=turn.context_tokens,
         )
         return result if skills is None else replace(result, skills=skills)
 

{agentshim-0.22.0 → agentshim-0.23.1}/agentshim/providers/codex/failures.py

@@ -6,14 +6,27 @@ Codex's own: it names a usage limit ("You've hit your usage limit",
 ``usage_limit_reached``), retries a lost stream ("stream disconnected",
 "Reconnecting...") and, once its retries run out, reports
 "exceeded retry limit, last status: <status>".
+
+A prompt the context window cannot hold arrives two ways. A request the
+Responses API refuses is relayed as the API's own JSON error body, whose
+``error.code`` is ``context_length_exceeded``; that code is read from the
+parsed body, never searched for in prose. An overflow Codex's own accounting
+catches is its message "Codex ran out of room in the model's context window".
 """
 
 from __future__ import annotations
 
+import json
 import re
+from typing import Any, cast
 
 from agentshim.core.errors import FailureKind
 
+#: The Responses API's ``error.code`` for a prompt longer than the window.
+CONTEXT_LENGTH_EXCEEDED = "context_length_exceeded"
+#: Codex's own message for ``CodexErr::ContextWindowExceeded``.
+_CONTEXT_WINDOW = re.compile(r"ran out of room in the model's context window", re.IGNORECASE)
+
 _USAGE_LIMIT = re.compile(
     r"hit your usage limit|usage_limit_(?:reached|exceeded)|insufficient_quota", re.IGNORECASE
 )
@@ -32,8 +45,12 @@ def classify_failure(text: str) -> FailureKind:
 
     The order matters: a usage limit is also reported with a 429 status, and
     an exhausted retry can end on a 401, so the specific kinds are checked
-    before the generic transient one.
+    before the generic transient one. A JSON error body is classified by its
+    code before any phrase is looked for.
     """
+    code = api_error_code(text)
+    if code == CONTEXT_LENGTH_EXCEEDED or _CONTEXT_WINDOW.search(text):
+        return FailureKind.CONTEXT_OVERFLOW
     if _USAGE_LIMIT.search(text):
         return FailureKind.USAGE_LIMIT
     if _AUTH.search(text):
@@ -41,3 +58,18 @@ def classify_failure(text: str) -> FailureKind:
     if _TRANSIENT.search(text):
         return FailureKind.TRANSIENT
     return FailureKind.OTHER
+
+
+def api_error_code(text: str) -> str | None:
+    """The ``error.code`` of *text* when it is an API error body, else ``None``."""
+    try:
+        body: object = json.loads(text)
+    except ValueError:
+        return None
+    if not isinstance(body, dict):
+        return None
+    error = cast("dict[str, Any]", body).get("error")
+    if not isinstance(error, dict):
+        return None
+    code = cast("dict[str, Any]", error).get("code")
+    return code if isinstance(code, str) else None

{agentshim-0.22.0 → agentshim-0.23.1}/agentshim/providers/codex/model_data.py

@@ -1,6 +1,7 @@
 """Codex-owned model and price facts."""
 
 import datetime as dt
+from dataclasses import replace
 
 from agentshim.core.models import ModelSpec
 from agentshim.core.pricing import ModelPricing
@@ -9,6 +10,8 @@ OPENAI_MODELS_URL = "https://developers.openai.com/api/docs/models"
 OPENAI_PRICING_URL = "https://developers.openai.com/api/docs/pricing"
 _MODEL_CHECKED = dt.date(2026, 10, 17)
 _PRICE_CHECKED = dt.date(2026, 9, 27)
+#: ``gpt-6.1-sol`` was read from the page on its own date, after the rest of the table.
+_SOL_6_1_CHECKED = dt.date(2026, 10, 30)
 
 
 def _openai_model(
@@ -88,6 +91,10 @@ def _openai(
 
 PRICING_ENTRIES = (
     _openai("gpt-6-astra", 10.00, 1.00, 50.00, cache_write_usd=12.50),
+    replace(
+        _openai("gpt-6.1-sol", 2.00, 0.10, 10.00, cache_write_usd=2.50),
+        checked=_SOL_6_1_CHECKED,
+    ),
     _openai("gpt-6-sol", 2.00, 0.20, 10.00, cache_write_usd=2.50),
     _openai("gpt-6-luna", 0.10, 0.01, 0.50, cache_write_usd=0.125),
     _openai("gpt-5.6-sol", 4.00, 0.40, 20.00, cache_write_usd=5.00),

{agentshim-0.22.0 → agentshim-0.23.1}/agentshim/providers/codex/scripted.py

@@ -131,7 +131,16 @@ _FAILURES: dict[FailureKind, str] = {
         "(https://chatgpt.com/explore/plus), or try again in 2 hours."
     ),
     FailureKind.AUTH: "unexpected status 401 Unauthorized: Missing bearer authentication",
-    FailureKind.OTHER: "Codex ran out of room in the model's context window.",
+    FailureKind.CONTEXT_OVERFLOW: (
+        '{"type":"error","error":{"message":"Your input exceeds the context window of this '
+        'model. Please adjust your input and try again.","type":"invalid_request_error",'
+        '"param":"input","code":"context_length_exceeded"},"status":400}'
+    ),
+    FailureKind.OTHER: (
+        '{"type":"error","status":400,"error":{"type":"invalid_request_error","message":'
+        "\"The 'no-such-model-xyz' model is not supported when using Codex with a ChatGPT "
+        'account."}}'
+    ),
 }
 
 

{agentshim-0.22.0 → agentshim-0.23.1}/agentshim/providers/opencode/parser.py

@@ -114,6 +114,8 @@ class OpencodeStreamParser:
         self._cost_usd: float | None = None
         self._raw_tokens: Mapping[str, Any] | None = None
         self._error: str | None = None
+        # The context the last step (one model call) left.
+        self._context_tokens: int | None = None
 
     def feed_stdout(self, line: str) -> None:
         """Consume one stdout line."""
@@ -143,6 +145,7 @@ class OpencodeStreamParser:
             usage=self._usage(),
             cost_usd=self._cost_usd,
             error=self._error,
+            context_tokens=self._context_tokens,
         )
 
     def _usage(self) -> ProviderUsage:
@@ -201,6 +204,12 @@ class OpencodeStreamParser:
     def _step_finish(self, frame: StepFinishEvent) -> None:
         step = fold_usage(frame.tokens)
         self._tokens = self._tokens + step
+        if frame.tokens is not None:
+            # One step is one model call: its whole prompt plus the answer it
+            # wrote. Reasoning is not sent back in the next step's prompt.
+            self._context_tokens = (
+                step.input_tokens + step.output_tokens - step.reasoning_output_tokens
+            )
         self._raw_tokens = frame.tokens if frame.tokens is not None else self._raw_tokens
         if frame.cost is not None:
             self._cost_usd = (self._cost_usd or 0.0) + frame.cost

{agentshim-0.22.0 → agentshim-0.23.1}/agentshim/testing/conversation.py

@@ -54,6 +54,8 @@ class FakeTurn:
     duration_ms: int = 0
     events: Sequence[AgentEvent] = ()
     during: Callable[[], None] | None = None
+    #: The ``TurnResult.context_tokens`` the turn reports.
+    context_tokens: int | None = None
 
 
 FakeOutcome = FakeTurn | AgentShimError
@@ -156,6 +158,7 @@ class FakeConversation:
             duration_ms=outcome.duration_ms,
             exit_code=0,
             interrupted=interrupted,
+            context_tokens=outcome.context_tokens,
         )
 
     def steer(self, text: str) -> None:

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

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

agentshim-0.23.1/tests/fixtures/claude/README.md

@@ -0,0 +1,13 @@
+# Claude Code stream-json recordings
+
+Real `claude -p --output-format stream-json --verbose` stdout. The `init`
+frame's lists of slash commands, skills, plugins, agents and MCP servers are
+emptied, and local paths are replaced with `/workspace`; every other frame is
+verbatim.
+
+| File | Covers |
+| --- | --- |
+| `haiku45_two_model_calls.jsonl` | Claude Code 2.1.304, `claude-haiku-4-5`: a `Read` call, then the answer, so two model calls in one turn |
+| `haiku45_prompt_too_long_blocking_limit.jsonl` | Claude Code 2.1.304, `claude-haiku-4-5`: a prompt over the CLI's own blocking limit; compaction fails, no request is sent, `terminal_reason: blocking_limit` |
+| `haiku45_prompt_too_long_api_400.jsonl` | Claude Code 2.1.304, `claude-haiku-4-5`: a prompt the CLI underestimated (random CJK text), refused by the API with a 400, `terminal_reason: prompt_too_long` |
+| `haiku_task_subagent.jsonl`, `skill_*_haiku.jsonl`, `sonnet_1h_cache.jsonl` | older recordings: a Task subagent, skill loads, one-hour cache writes |

{agentshim-0.22.0 → agentshim-0.23.1}/tests/fixtures/codex/README.md

@@ -16,3 +16,9 @@ contained no two-invocation recording.
 Codex 0.144.4's JSON event processor copies all five fields from the thread
 usage `total` into `turn.completed.usage`; it does not expose a per-turn field:
 [provider source](https://github.com/openai/codex/blob/rust-v0.144.4/codex-rs/exec/src/event_processor_with_jsonl_output.rs).
+
+`exec_context_overflow_gpt6_luna.jsonl` is recorded `codex exec --json` stdout
+(codex-cli 0.160.0, `gpt-6-luna`, 2026-10-20) for a prompt of 700,000 random
+CJK characters, about 1.4 million tokens. The Responses API refuses it, and
+Codex relays the API's error body, code `context_length_exceeded`, as the
+`error` and `turn.failed` message.

{agentshim-0.22.0 → agentshim-0.23.1}/tests/fixtures/codex_app_server/README.md

@@ -1,6 +1,6 @@
 # Codex app-server transcripts
 
-Three recorded sessions of `codex app-server` (codex-cli 0.160.0, model
+Four recorded sessions of `codex app-server` (codex-cli 0.160.0, model
 `gpt-6-luna`, low effort) over stdio. Each line is
 `{"dir": "out" | "in", "msg": {...}}`: `out` is what the client wrote, `in` what
 the server wrote. They are scrubbed: the Codex home is `$CODEX_HOME`, the
@@ -12,6 +12,7 @@ placeholders.
 | `session_1.jsonl` | handshake, `thread/resume` errors (unknown and malformed id), two threads in one process, a plain turn |
 | `session_2.jsonl` | `workspace-write` with `untrusted` approvals: a declined command approval, a command that runs, `turn/interrupt` |
 | `session_3.jsonl` | `thread/resume` across processes, a structured-output turn, per-thread MCP config that fails to start, a failed turn (unknown model) |
+| `session_4.jsonl` | a plain turn whose `last` and `total` usage agree, then a turn of 700,000 random CJK characters that the Responses API refuses with `context_length_exceeded`, relayed under `codexErrorInfo: other`; recorded 2026-10-20, the long prompt is elided |
 
 `tests/unit/providers/codex/app_server/test_replay.py` parses every line.
 Re-record them only when the CLI version in