Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python

fix: recover Groq requests above TPM allowance (#1634)

Ali Khokhar4a9ec738641b
diff --git a/pyproject.toml b/pyproject.toml
index a8a89203..771e2384 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
[project]
name = "free-claude-code"
-version = "5.18.9"
+version = "5.18.10"
description = "Local proxy connecting coding agents to OpenAI-compatible AI providers"
readme = "README.md"
requires-python = ">=3.14.0"
diff --git a/src/free_claude_code/providers/groq/client.py b/src/free_claude_code/providers/groq/client.py
index 605e5668..99387a75 100644
--- a/src/free_claude_code/providers/groq/client.py
+++ b/src/free_claude_code/providers/groq/client.py
@@ -10,6 +10,7 @@ import openai
from loguru import logger
from free_claude_code.core.anthropic import ReasoningReplayMode
+from free_claude_code.core.json_types import JsonObject
from free_claude_code.core.reasoning import (
ReasoningEffort,
ReasoningPolicy,
@@ -25,6 +26,8 @@ from free_claude_code.providers.openai_chat import (
validate_extra_body_does_not_override_reasoning_fields,
)
+from .tpm import correct_tpm_completion_budget
+
_GROQ_EFFORTS = (
(ReasoningEffort.MINIMAL, "low"),
(ReasoningEffort.LOW, "low"),
@@ -135,6 +138,30 @@ class GroqProvider(OpenAIChatProvider):
logger.warning("GROQ_STREAM: {} after upstream rejection", action)
return retry_body
+ def _next_create_retry_body(
+ self,
+ error: Exception,
+ body: JsonObject,
+ used_retry_kinds: set[str],
+ ) -> JsonObject | None:
+ retry_body = super()._next_create_retry_body(error, body, used_retry_kinds)
+ if retry_body is not None or "groq_tpm" in used_retry_kinds:
+ return retry_body
+
+ correction = correct_tpm_completion_budget(error, body)
+ if correction is None:
+ return None
+ used_retry_kinds.add("groq_tpm")
+ logger.warning(
+ "GROQ_STREAM: TPM limit={} requested={}; retrying "
+ "max_completion_tokens {} -> {}",
+ correction.limit,
+ correction.requested,
+ correction.previous_max_completion_tokens,
+ correction.corrected_max_completion_tokens,
+ )
+ return correction.body
+
def _parse_reasoning_vocabulary(error: Exception) -> frozenset[str] | None:
"""Return Groq's accepted known values, or an understood empty vocabulary."""
diff --git a/src/free_claude_code/providers/groq/tpm.py b/src/free_claude_code/providers/groq/tpm.py
new file mode 100644
index 00000000..78cfc4b9
--- /dev/null
+++ b/src/free_claude_code/providers/groq/tpm.py
@@ -0,0 +1,108 @@
+"""Strict request-local correction for Groq TPM-size rejections."""
+
+import re
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+from free_claude_code.core.json_types import JsonObject, JsonValue
+
+_MAX_DECIMAL_DIGITS = 19
+_TPM_PREFIX = r"(?<![a-z])tokens\s+per\s+minute\s*\(\s*tpm\s*\)\s*:\s*"
+_TPM_MARKER = re.compile(_TPM_PREFIX, re.IGNORECASE)
+_TPM_CLAUSE = re.compile(
+ _TPM_PREFIX
+ + rf"limit\s+([0-9]{{1,{_MAX_DECIMAL_DIGITS}}})(?![0-9])\s*,\s*"
+ + rf"requested\s+([0-9]{{1,{_MAX_DECIMAL_DIGITS}}})"
+ + r"(?=\s*(?:,(?!\s*[0-9])|$))",
+ re.IGNORECASE,
+)
+_OUTPUT_FIELDS = frozenset({"max_completion_tokens", "max_tokens"})
+_DETAIL_FIELDS = frozenset({"message", "type", "code"})
+
+
+@dataclass(frozen=True, slots=True)
+class GroqTpmCorrection:
+ """One validated completion-budget correction and its safe diagnostics."""
+
+ body: JsonObject
+ limit: int
+ requested: int
+ previous_max_completion_tokens: int
+ corrected_max_completion_tokens: int
+
+
+def correct_tpm_completion_budget(
+ error: Exception,
+ body: Mapping[str, JsonValue],
+) -> GroqTpmCorrection | None:
+ """Subtract Groq's reported TPM overage from this request's output cap."""
+ if _status_code(error) != 413:
+ return None
+
+ detail = _error_detail(getattr(error, "body", None))
+ if detail is None:
+ return None
+ if detail.get("type") != "tokens":
+ return None
+ if detail.get("code") != "rate_limit_exceeded":
+ return None
+
+ message = detail.get("message")
+ if not isinstance(message, str):
+ return None
+ if sum(1 for _ in _TPM_MARKER.finditer(message)) != 1:
+ return None
+ matches = tuple(_TPM_CLAUSE.finditer(message))
+ if len(matches) != 1:
+ return None
+
+ limit = int(matches[0].group(1))
+ requested = int(matches[0].group(2))
+ if limit <= 0 or requested <= limit:
+ return None
+
+ previous = body.get("max_completion_tokens")
+ if not isinstance(previous, int) or isinstance(previous, bool) or previous <= 0:
+ return None
+ if requested <= previous:
+ return None
+ extra_body = body.get("extra_body")
+ if isinstance(extra_body, Mapping) and any(
+ field in extra_body for field in _OUTPUT_FIELDS
+ ):
+ return None
+
+ corrected = previous - (requested - limit)
+ if corrected <= 0 or corrected >= previous:
+ return None
+
+ corrected_body = dict(body)
+ corrected_body["max_completion_tokens"] = corrected
+ return GroqTpmCorrection(
+ body=corrected_body,
+ limit=limit,
+ requested=requested,
+ previous_max_completion_tokens=previous,
+ corrected_max_completion_tokens=corrected,
+ )
+
+
+def _status_code(error: Exception) -> int | None:
+ status = getattr(error, "status_code", None)
+ if isinstance(status, int) and not isinstance(status, bool):
+ return status
+ response = getattr(error, "response", None)
+ status = getattr(response, "status_code", None)
+ return status if isinstance(status, int) and not isinstance(status, bool) else None
+
+
+def _error_detail(value: object) -> Mapping[object, object] | None:
+ if not isinstance(value, Mapping):
+ return None
+ candidates: list[Mapping[object, object]] = []
+ if _DETAIL_FIELDS.issubset(value):
+ candidates.append(value)
+ nested = value.get("error")
+ if isinstance(nested, Mapping) and _DETAIL_FIELDS.issubset(nested):
+ candidates.append(nested)
+ return candidates[0] if len(candidates) == 1 else None
diff --git a/src/free_claude_code/providers/openai_chat/provider.py b/src/free_claude_code/providers/openai_chat/provider.py
index 481ce5e8..c8a29f9e 100644
--- a/src/free_claude_code/providers/openai_chat/provider.py
+++ b/src/free_claude_code/providers/openai_chat/provider.py
@@ -35,6 +35,7 @@ from free_claude_code.core.anthropic.streaming import (
)
from free_claude_code.core.anthropic.usage import anthropic_input_usage_fields
from free_claude_code.core.failures import ExecutionFailure
+from free_claude_code.core.json_types import JsonObject
from free_claude_code.core.openai_responses import (
OpenAIResponsesRequest,
ResponsesChatRequest,
@@ -116,6 +117,7 @@ class _CollectedRecoveryOutput:
text: str
thinking: str
tool_calls: tuple[CompletedOpenAIToolCall, ...]
+ request_body: JsonObject
def _iter_visible_text_events(
@@ -770,10 +772,13 @@ class OpenAIChatProvider(BaseProvider):
body: dict,
execution: ProviderExecution,
operation_kind: ProviderOperationKind,
+ *,
+ used_retry_kinds: set[str] | None = None,
) -> tuple[Any, dict, ProviderAttempt]:
"""Create a streaming chat completion with bounded request fallbacks."""
body = self._apply_learned_output_cap(body)
- used_retry_kinds: set[str] = set()
+ if used_retry_kinds is None:
+ used_retry_kinds = set()
while execution.can_attempt:
attempt = await execution.open_attempt(operation_kind)
@@ -1019,6 +1024,7 @@ class _OpenAIChatStreamRunner:
body = self._body
request_stream_usage(body)
output_reasoning = self._reasoning.output_enabled
+ used_retry_kinds: set[str] = set()
trace_event(
stage="provider",
event="provider.request.sent",
@@ -1041,6 +1047,7 @@ class _OpenAIChatStreamRunner:
body,
execution,
ProviderOperationKind.GENERATION,
+ used_retry_kinds=used_retry_kinds,
)
scope = ProviderAttemptScope(
attempt,
@@ -1288,16 +1295,20 @@ class _OpenAIChatStreamRunner:
include_reasoning: bool,
execution: ProviderExecution,
operation_kind: ProviderOperationKind,
+ used_retry_kinds: set[str] | None = None,
) -> _CollectedRecoveryOutput:
"""Collect one complete buffered continuation response."""
+ if used_retry_kinds is None:
+ used_retry_kinds = set()
last_error: Exception | None = None
while execution.can_attempt:
scope: ProviderAttemptScope | None = None
try:
- stream, accepted_body, attempt = await self._provider._create_stream(
+ stream, body, attempt = await self._provider._create_stream(
body,
execution,
operation_kind,
+ used_retry_kinds=used_retry_kinds,
)
scope = ProviderAttemptScope(
attempt,
@@ -1335,9 +1346,7 @@ class _OpenAIChatStreamRunner:
completed_tool_calls = tool_calls.completed_calls(
self._tool_schemas,
tool_names=self._tool_names,
- tool_argument_aliases=self._provider._tool_argument_aliases(
- accepted_body
- ),
+ tool_argument_aliases=self._provider._tool_argument_aliases(body),
)
if tool_calls.has_calls and completed_tool_calls is None:
raise TruncatedProviderStreamError(
@@ -1351,6 +1360,7 @@ class _OpenAIChatStreamRunner:
text="".join(text_parts),
thinking="".join(thinking_parts),
tool_calls=completed_tool_calls or (),
+ request_body=body,
)
except Exception as error:
last_error = error
@@ -1380,7 +1390,12 @@ class _OpenAIChatStreamRunner:
await scope.aclose(active_error=sys.exception())
if last_error is not None:
raise last_error
- return _CollectedRecoveryOutput(text="", thinking="", tool_calls=())
+ return _CollectedRecoveryOutput(
+ text="",
+ thinking="",
+ tool_calls=(),
+ request_body=body,
+ )
async def _recovery_events(
self,
@@ -1516,6 +1531,7 @@ class _OpenAIChatStreamRunner:
)
accepted_suffix: str | None = None
repair_attempt = 0
+ used_retry_kinds: set[str] = set()
while execution.can_attempt:
repair_attempt += 1
recovered = await self._collect_recovery_output(
@@ -1523,6 +1539,7 @@ class _OpenAIChatStreamRunner:
include_reasoning=False,
execution=execution,
operation_kind=ProviderOperationKind.TOOL_REPAIR,
+ used_retry_kinds=used_retry_kinds,
)
repair = accept_tool_json_repair(
repair_prefix,
@@ -1541,6 +1558,7 @@ class _OpenAIChatStreamRunner:
attempt=repair_attempt,
)
break
+ recovery_body = recovered.request_body
if accepted_suffix is None:
return None
to_emit = (
diff --git a/tests/providers/test_groq_tpm.py b/tests/providers/test_groq_tpm.py
new file mode 100644
index 00000000..34791b0c
--- /dev/null
+++ b/tests/providers/test_groq_tpm.py
@@ -0,0 +1,350 @@
+"""Groq request-local recovery from exact TPM-size rejections."""
+
+from copy import deepcopy
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx2
+import openai
+import pytest
+
+from free_claude_code.config.provider_catalog import GROQ_DEFAULT_BASE
+from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
+from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
+from free_claude_code.providers.admission import ProviderOperationKind
+from free_claude_code.providers.groq import GroqProvider
+from free_claude_code.providers.groq.tpm import correct_tpm_completion_budget
+from tests.providers.request_factory import make_messages_request
+from tests.providers.support import immediate_admission, make_provider_config
+
+_MODEL = "openai/gpt-oss-120b"
+_LIMIT = 8_000
+_REQUESTED = 26_206
+_ORIGINAL_MAX = 24_576
+_CORRECTED_MAX = 6_370
+
+
+def _detail(
+ message: str = (
+ "Request too large for model `openai/gpt-oss-120b` on tokens per minute "
+ "(TPM): Limit 8000, Requested 26206, please reduce your message size"
+ ),
+ *,
+ error_type: str = "tokens",
+ code: str = "rate_limit_exceeded",
+) -> dict[str, str]:
+ return {"message": message, "type": error_type, "code": code}
+
+
+def _status_error(
+ *,
+ status: int = 413,
+ detail: object | None = None,
+ wrapped: bool = False,
+) -> openai.APIStatusError:
+ request = httpx2.Request("POST", f"{GROQ_DEFAULT_BASE}/chat/completions")
+ response = httpx2.Response(status, request=request)
+ body = _detail() if detail is None else detail
+ if wrapped:
+ body = {"error": body}
+ return openai.APIStatusError(
+ "Groq request rejected",
+ response=response,
+ body=body,
+ )
+
+
+def _body(max_completion_tokens: object = _ORIGINAL_MAX) -> dict:
+ return {
+ "model": _MODEL,
+ "messages": [{"role": "user", "content": "hello"}],
+ "max_completion_tokens": max_completion_tokens,
+ }
+
+
+def _provider(*, max_attempts: int = 5) -> GroqProvider:
+ return GroqProvider(
+ make_provider_config("test-groq-key", GROQ_DEFAULT_BASE),
+ admission=immediate_admission(
+ provider_name="GROQ",
+ max_attempts=max_attempts,
+ ),
+ )
+
+
+def _chunk(*, content: str | None = None, finish_reason: str | None = None):
+ return MagicMock(
+ choices=[
+ MagicMock(
+ delta=MagicMock(
+ content=content,
+ reasoning_content=None,
+ tool_calls=None,
+ ),
+ finish_reason=finish_reason,
+ )
+ ],
+ usage=None,
+ )
+
+
+async def _successful_stream():
+ yield _chunk(content="working")
+ yield _chunk(finish_reason="stop")
+
+
[email protected]("wrapped", [False, True], ids=["sdk-detail", "wire-wrapper"])
+def test_exact_tpm_rejection_corrects_only_completion_budget(wrapped: bool) -> None:
+ body = _body()
+ original = deepcopy(body)
+
+ correction = correct_tpm_completion_budget(
+ _status_error(wrapped=wrapped),
+ body,
+ )
+
+ assert correction is not None
+ assert correction.limit == _LIMIT
+ assert correction.requested == _REQUESTED
+ assert correction.previous_max_completion_tokens == _ORIGINAL_MAX
+ assert correction.corrected_max_completion_tokens == _CORRECTED_MAX
+ assert correction.body == {**body, "max_completion_tokens": _CORRECTED_MAX}
+ assert correction.body is not body
+ assert body == original
+
+
+ ("error", "body"),
+ [
+ (_status_error(status=429), _body()),
+ (_status_error(detail=_detail(error_type="rate_limit")), _body()),
+ (_status_error(detail=_detail(code="context_length_exceeded")), _body()),
+ (_status_error(detail=_detail("Request too large")), _body()),
+ (
+ _status_error(
+ detail=_detail(
+ "tokens per minute (TPM): Limit 8000, Requested 26206garbage"
+ )
+ ),
+ _body(),
+ ),
+ (
+ _status_error(
+ detail=_detail(
+ "tokens per minute (TPM): Limit 8000, Requested 26206,000"
+ )
+ ),
+ _body(),
+ ),
+ (
+ _status_error(
+ detail=_detail(
+ "tokens per minute (TPM): Limit 8000, Requested 26206, 000"
+ )
+ ),
+ _body(),
+ ),
+ (
+ _status_error(
+ detail=_detail(
+ "tokens per minute (TPM): Limit 8000, Requested 26206; "
+ "tokens per minute (TPM): Limit 8000, Requested 26206"
+ )
+ ),
+ _body(),
+ ),
+ (
+ _status_error(
+ detail=_detail("tokens per minute (TPM): Limit 8000, Requested 8000")
+ ),
+ _body(),
+ ),
+ (
+ _status_error(
+ detail=_detail("tokens per minute (TPM): Limit 8000, Requested 9000")
+ ),
+ _body(),
+ ),
+ (
+ _status_error(
+ detail=_detail("tokens per minute (TPM): Limit 8000, Requested 24576")
+ ),
+ _body(),
+ ),
+ (
+ _status_error(
+ detail=_detail(
+ "tokens per minute (TPM): Limit 80000000000000000000, "
+ "Requested 90000000000000000000"
+ )
+ ),
+ _body(),
+ ),
+ (_status_error(), _body(None)),
+ (_status_error(), _body(True)),
+ (_status_error(), _body(10_000)),
+ (
+ _status_error(),
+ {**_body(), "extra_body": {"max_completion_tokens": _ORIGINAL_MAX}},
+ ),
+ (
+ _status_error(),
+ {**_body(), "extra_body": {"max_tokens": _ORIGINAL_MAX}},
+ ),
+ ],
+ ids=[
+ "wrong-status",
+ "wrong-type",
+ "wrong-code",
+ "missing-clause",
+ "malformed-requested-boundary",
+ "grouped-requested-no-space",
+ "grouped-requested-with-space",
+ "ambiguous-clause",
+ "no-overage",
+ "requested-under-output-cap",
+ "requested-equals-output-cap",
+ "oversized-number",
+ "non-integer-max",
+ "boolean-max",
+ "prompt-alone-too-large",
+ "extra-max-completion-tokens",
+ "extra-max-tokens",
+ ],
+)
+def test_non_authoritative_tpm_rejection_is_not_corrected(
+ error: Exception,
+ body: dict,
+) -> None:
+ assert correct_tpm_completion_budget(error, body) is None
+
+
+async def test_tpm_correction_emits_one_downstream_lifecycle() -> None:
+ provider = _provider()
+ request = make_messages_request(_MODEL, max_tokens=_ORIGINAL_MAX)
+ create = AsyncMock(side_effect=[_status_error(), _successful_stream()])
+
+ with patch.object(provider._client.chat.completions, "create", create):
+ raw = "".join(
+ [
+ event
+ async for event in provider.stream_messages(
+ request,
+ reasoning=ReasoningPolicy.off(),
+ )
+ ]
+ )
+
+ events = parse_sse_text(raw)
+ assert create.await_count == 2
+ assert create.await_args_list[0].kwargs["max_completion_tokens"] == _ORIGINAL_MAX
+ assert create.await_args_list[1].kwargs["max_completion_tokens"] == _CORRECTED_MAX
+ assert "working" in raw
+ assert "event: error" not in raw
+ assert sum(event.event == "message_start" for event in events) == 1
+ assert sum(event.event == "message_stop" for event in events) == 1
+
+
+async def test_tpm_correction_is_one_shot_per_stream_creation() -> None:
+ provider = _provider()
+ create = AsyncMock(side_effect=[_status_error(), _status_error()])
+
+ with (
+ patch.object(provider._client.chat.completions, "create", create),
+ pytest.raises(openai.APIStatusError),
+ ):
+ await provider._create_stream(
+ _body(),
+ provider._admission.start_execution(),
+ ProviderOperationKind.GENERATION,
+ )
+
+ assert create.await_count == 2
+
+
+async def test_tpm_correction_respects_physical_attempt_ceiling() -> None:
+ provider = _provider(max_attempts=1)
+ create = AsyncMock(side_effect=_status_error())
+
+ with (
+ patch.object(provider._client.chat.completions, "create", create),
+ pytest.raises(openai.APIStatusError),
+ ):
+ await provider._create_stream(
+ _body(),
+ provider._admission.start_execution(),
+ ProviderOperationKind.GENERATION,
+ )
+
+ assert create.await_count == 1
+
+
+def _reasoning_error() -> openai.APIStatusError:
+ message = "`reasoning_effort` value `high` must be one of `none` or `default`"
+ return _status_error(
+ status=400,
+ detail={"message": message, "type": "invalid_request_error"},
+ )
+
+
[email protected]("errors", [("tpm", "reasoning"), ("reasoning", "tpm")])
+async def test_tpm_and_reasoning_corrections_compose(
+ errors: tuple[str, str],
+) -> None:
+ provider = _provider()
+ request = make_messages_request(_MODEL, max_tokens=_ORIGINAL_MAX)
+ body = provider._build_request_body(
+ request,
+ reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),
+ )
+ failures = {
+ "tpm": _status_error(),
+ "reasoning": _reasoning_error(),
+ }
+ create = AsyncMock(side_effect=[*(failures[name] for name in errors), object()])
+ execution = provider._admission.start_execution()
+
+ with patch.object(provider._client.chat.completions, "create", create):
+ _stream, accepted_body, attempt = await provider._create_stream(
+ body,
+ execution,
+ ProviderOperationKind.GENERATION,
+ )
+ await attempt.aclose()
+
+ assert create.await_count == 3
+ assert execution.attempts_started == 3
+ assert accepted_body["max_completion_tokens"] == _CORRECTED_MAX
+ assert accepted_body["reasoning_effort"] == "default"
+
+
+async def test_distinct_bodies_get_independent_tpm_corrections() -> None:
+ provider = _provider()
+ execution = provider._admission.start_execution()
+ second_error = _status_error(
+ detail=_detail("tokens per minute (TPM): Limit 8000, Requested 22000")
+ )
+ create = AsyncMock(side_effect=[_status_error(), object(), second_error, object()])
+
+ with patch.object(provider._client.chat.completions, "create", create):
+ _stream, first_body, first_attempt = await provider._create_stream(
+ _body(),
+ execution,
+ ProviderOperationKind.CONTINUATION,
+ )
+ await first_attempt.accept()
+ await first_attempt.aclose()
+ _stream, second_body, second_attempt = await provider._create_stream(
+ _body(20_000),
+ execution,
+ ProviderOperationKind.TOOL_REPAIR,
+ )
+ await second_attempt.aclose()
+
+ assert execution.attempts_started == 4
+ assert first_body["max_completion_tokens"] == _CORRECTED_MAX
+ assert second_body["max_completion_tokens"] == 6_000
diff --git a/tests/providers/test_streaming_errors.py b/tests/providers/test_streaming_errors.py
index b48c3ba7..f1c6d059 100644
--- a/tests/providers/test_streaming_errors.py
+++ b/tests/providers/test_streaming_errors.py
@@ -1644,6 +1644,154 @@ class TestStreamingExceptionHandling:
assert create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS
assert all(stream.closed for stream in streams)
+ @pytest.mark.asyncio
+ async def test_recovery_stream_reopen_retains_accepted_corrected_body(self):
+ """Reopening one derived request reuses its accepted correction."""
+ provider = _make_provider()
+ runner = _make_stream_runner(provider)
+ execution = provider._admission.start_execution()
+ response = httpx2.Response(
+ status_code=400,
+ request=httpx2.Request("POST", "https://example.com/v1/chat/completions"),
+ )
+ usage_rejection = openai.BadRequestError(
+ "stream_options is unsupported",
+ response=response,
+ body={"error": {"message": "stream_options is unsupported"}},
+ )
+ failed_stream = ClosableAsyncStreamMock(
+ [_make_chunk(content="discarded")],
+ error=httpx.ReadError("recovery cutoff"),
+ )
+ successful_stream = ClosableAsyncStreamMock(
+ [_make_chunk(content="visible"), _make_chunk(finish_reason="stop")]
+ )
+ body = {
+ "messages": [],
+ "stream_options": {"include_usage": True},
+ }
+
+ with (
+ patch.object(
+ provider,
+ "_create_stream",
+ new_callable=AsyncMock,
+ wraps=provider._create_stream,
+ ) as create_stream,
+ patch.object(
+ provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ side_effect=[usage_rejection, failed_stream, successful_stream],
+ ) as create,
+ ):
+ recovered = await runner._collect_recovery_output(
+ body,
+ include_reasoning=True,
+ execution=execution,
+ operation_kind=ProviderOperationKind.CONTINUATION,
+ )
+
+ assert create.await_count == 3
+ assert create.await_args_list[0].kwargs["stream_options"] == {
+ "include_usage": True
+ }
+ assert "stream_options" not in create.await_args_list[1].kwargs
+ assert "stream_options" not in create.await_args_list[2].kwargs
+ assert create_stream.await_count == 2
+ assert (
+ create_stream.await_args_list[0].kwargs["used_retry_kinds"]
+ is create_stream.await_args_list[1].kwargs["used_retry_kinds"]
+ )
+ assert recovered.text == "visible"
+ assert failed_stream.closed
+ assert successful_stream.closed
+
+ @pytest.mark.asyncio
+ async def test_tool_repair_iterations_reuse_accepted_corrected_body(self):
+ """Schema-repair retries reuse corrections accepted for that repair body."""
+ provider = _make_provider()
+ request = _make_request(
+ tools=[
+ {
+ "name": "echo_smoke",
+ "description": "Echo one message",
+ "input_schema": {
+ "type": "object",
+ "properties": {"message": {"type": "string"}},
+ "required": ["message"],
+ "additionalProperties": False,
+ },
+ }
+ ]
+ )
+ runner = _make_stream_runner(provider, request=request)
+ assembler = runner._new_stream_assembler(output_reasoning=False)
+ tuple(assembler.start_events())
+ tuple(
+ assembler.feed(
+ _make_tool_calls_chunk(
+ name="echo_smoke",
+ arguments='{"message":',
+ tool_id="call_repair",
+ )
+ )
+ )
+ body = provider._build_request_body(request)
+ body["stream_options"] = {"include_usage": True}
+ response = httpx2.Response(
+ status_code=400,
+ request=httpx2.Request("POST", "https://example.com/v1/chat/completions"),
+ )
+ usage_rejection = openai.BadRequestError(
+ "stream_options is unsupported",
+ response=response,
+ body={"error": {"message": "stream_options is unsupported"}},
+ )
+ invalid_repair = ClosableAsyncStreamMock(
+ [_make_chunk(content="123}"), _make_chunk(finish_reason="stop")]
+ )
+ valid_repair = ClosableAsyncStreamMock(
+ [_make_chunk(content='"ok"}'), _make_chunk(finish_reason="stop")]
+ )
+ execution = provider._admission.start_execution()
+
+ with (
+ patch.object(
+ provider,
+ "_create_stream",
+ new_callable=AsyncMock,
+ wraps=provider._create_stream,
+ ) as create_stream,
+ patch.object(
+ provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ side_effect=[usage_rejection, invalid_repair, valid_repair],
+ ) as create,
+ ):
+ events = await runner._repair_tool_args(
+ body=body,
+ output=assembler.output,
+ tool_argument_alias_buffers=assembler.tool_argument_alias_buffers,
+ execution=execution,
+ )
+
+ assert events is not None
+ assert create.await_count == 3
+ assert create.await_args_list[0].kwargs["stream_options"] == {
+ "include_usage": True
+ }
+ assert "stream_options" not in create.await_args_list[1].kwargs
+ assert "stream_options" not in create.await_args_list[2].kwargs
+ assert create_stream.await_count == 2
+ assert (
+ create_stream.await_args_list[0].kwargs["used_retry_kinds"]
+ is create_stream.await_args_list[1].kwargs["used_retry_kinds"]
+ )
+ assert invalid_repair.closed
+ assert valid_repair.closed
+
@pytest.mark.asyncio
async def test_recovery_collect_text_accepts_finish_reason(self):
"""Recovery collectors return text only after the upstream terminal marker."""
diff --git a/uv.lock b/uv.lock
index a629acbb..958782cb 100644
--- a/uv.lock
+++ b/uv.lock
@@ -598,7 +598,7 @@ wheels = [
[[package]]
name = "free-claude-code"
-version = "5.18.9"
+version = "5.18.10"
source = { editable = "." }
dependencies = [
{ name = "aiohttp" },