free-claude-code 6.3.1__tar.gz → 6.3.2__tar.gz

{free_claude_code-6.3.1 → free_claude_code-6.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: free-claude-code
-Version: 6.3.1
+Version: 6.3.2
 Summary: Local proxy connecting coding agents to OpenAI-compatible AI providers
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

{free_claude_code-6.3.1 → free_claude_code-6.3.2}/e2e/test_code_sessions.py

@@ -597,14 +597,18 @@ def test_settings_apply_preserves_open_creation_and_picker(
     page, admin_base_url, tmp_path, code_control
 ):
     pending = []
-    page.route("**/admin/api/config/apply", lambda route: pending.append(route))
-    page.expose_function("applyRequestIntercepted", lambda: bool(pending))
+
+    def capture_apply(route):
+        pending.append(route)
+        page.evaluate("window.applyRequestIntercepted = true")
+
+    page.route("**/admin/api/config/apply", capture_apply)
     page.goto(f"{admin_base_url}/admin")
     expect(page.locator("#messageArea")).to_have_text("")
     page.locator("#field-PORT").fill("8081")
     page.get_by_role("button", name="Apply", exact=True).click()
     expect(page.locator("#messageArea")).to_have_text("Applying…")
-    page.wait_for_function("window.applyRequestIntercepted()")
+    page.wait_for_function("window.applyRequestIntercepted === true")
     assert len(pending) == 1
     page.get_by_role("button", name="Code sessions", exact=True).click()
     page.get_by_role("button", name="New code session", exact=True).click()

{free_claude_code-6.3.1 → free_claude_code-6.3.2}/smoke/lib/e2e.py

@@ -32,6 +32,7 @@ from free_claude_code.messaging.voice import VoiceCancellationResult
 from free_claude_code.messaging.workflow import MessagingWorkflow
 from smoke.lib.child_process import run_captured_text
 from smoke.lib.config import ProviderModel, SmokeConfig, auth_headers
+from smoke.lib.http import conversation_headers
 from smoke.lib.server import RunningServer, start_server
 from smoke.lib.skips import fail_missing_env, skip_if_upstream_unavailable_events
 
@@ -88,6 +89,7 @@ class ConversationDriver:
         self.config = config
         self.messages: list[dict[str, Any]] = []
         self.turns: list[ConversationTurn] = []
+        self._session_id = str(uuid.uuid4())
 
     def ask(
         self,
@@ -120,7 +122,7 @@ class ConversationDriver:
         *,
         headers: dict[str, str] | None = None,
     ) -> ConversationTurn:
-        request_headers = headers or auth_headers()
+        request_headers = conversation_headers(headers, session_id=self._session_id)
         stream_payload = {**payload, "stream": True}
         with httpx.stream(
             "POST",
@@ -148,7 +150,7 @@ class ConversationDriver:
     ) -> dict[str, Any]:
         response = httpx.post(
             f"{self.server.base_url}/v1/messages",
-            headers=auth_headers(),
+            headers=conversation_headers(session_id=self._session_id),
             json=payload,
             timeout=self.config.timeout_s,
         )

{free_claude_code-6.3.1 → free_claude_code-6.3.2}/smoke/lib/http.py

@@ -1,5 +1,6 @@
 """HTTP helpers for live smoke requests."""
 
+import uuid
 from typing import Any
 
 import httpx
@@ -10,6 +11,16 @@ from .config import SmokeConfig, auth_headers, redacted
 from .server import RunningServer
 
 
+def conversation_headers(
+    headers: dict[str, str] | None = None, *, session_id: str | None = None
+) -> dict[str, str]:
+    """Identify a smoke conversation while preserving explicit caller headers."""
+    result = httpx.Headers(auth_headers() if headers is None else headers)
+    result.setdefault("user-agent", "fcc-smoke/1.0")
+    result.setdefault("x-opencode-session", session_id or str(uuid.uuid4()))
+    return dict(result)
+
+
 def message_payload(
     text: str,
     *,
@@ -35,7 +46,7 @@ def post_json(
     *,
     headers: dict[str, str] | None = None,
 ) -> httpx.Response:
-    request_headers = headers or auth_headers()
+    request_headers = conversation_headers(headers)
     response = httpx.post(
         f"{server.base_url}{path}",
         headers=request_headers,
@@ -52,7 +63,7 @@ def collect_message_stream(
     *,
     headers: dict[str, str] | None = None,
 ) -> list[SSEEvent]:
-    request_headers = headers or auth_headers()
+    request_headers = conversation_headers(headers)
     stream_payload = {**payload, "stream": True}
     with httpx.stream(
         "POST",

{free_claude_code-6.3.1 → free_claude_code-6.3.2}/smoke/prereq/test_provider_prereq_live.py

@@ -8,9 +8,9 @@ from free_claude_code.core.anthropic.stream_contracts import (
     text_content,
     thinking_content,
 )
-from smoke.lib.config import ProviderModel, SmokeConfig, auth_headers
+from smoke.lib.config import ProviderModel, SmokeConfig
 from smoke.lib.e2e import ProviderMatrixDriver
-from smoke.lib.http import collect_message_stream, message_payload
+from smoke.lib.http import collect_message_stream, conversation_headers, message_payload
 from smoke.lib.server import start_server
 from smoke.lib.skips import (
     skip_if_upstream_unavailable_events,
@@ -97,7 +97,7 @@ def test_client_disconnect_mid_stream_does_not_crash_server(
         with httpx.stream(
             "POST",
             f"{server.base_url}/v1/messages",
-            headers=auth_headers(),
+            headers=conversation_headers(),
             json=message_payload(smoke_config.prompt, model="fcc-smoke-default"),
             timeout=smoke_config.timeout_s,
         ) as response:

{free_claude_code-6.3.1 → free_claude_code-6.3.2}/smoke/product/test_provider_product_live.py

@@ -9,7 +9,7 @@ from free_claude_code.core.anthropic.stream_contracts import (
     SSEEvent,
     parse_sse_lines,
 )
-from smoke.lib.config import ProviderModel, SmokeConfig, auth_headers
+from smoke.lib.config import ProviderModel, SmokeConfig
 from smoke.lib.e2e import (
     ConversationDriver,
     ProviderMatrixDriver,
@@ -19,7 +19,7 @@ from smoke.lib.e2e import (
     echo_tool_schema,
     tool_use_blocks,
 )
-from smoke.lib.http import collect_message_stream
+from smoke.lib.http import collect_message_stream, conversation_headers
 from smoke.lib.skips import (
     skip_if_upstream_unavailable_events,
     skip_if_upstream_unavailable_exception,
@@ -166,7 +166,7 @@ def test_provider_error_e2e(smoke_config: SmokeConfig) -> None:
     ):
         response = client.post(
             f"{server.base_url}/v1/messages",
-            headers=auth_headers(),
+            headers=conversation_headers(),
             json={
                 "model": "fcc-smoke-default",
                 "max_tokens": 32,
@@ -605,11 +605,12 @@ def _scenario_reasoning_tool_continuation(
 def _scenario_disconnect(
     smoke_config: SmokeConfig, provider_model: ProviderModel
 ) -> None:
+    headers = conversation_headers()
     with _server_for_provider(smoke_config, provider_model, "disconnect") as server:
         with httpx.stream(
             "POST",
             f"{server.base_url}/v1/messages",
-            headers=auth_headers(),
+            headers=headers,
             json={
                 "model": "fcc-smoke-default",
                 "max_tokens": 512,
@@ -623,7 +624,7 @@ def _scenario_disconnect(
         health = httpx.get(f"{server.base_url}/health", timeout=5)
         assert health.status_code == 200
         followup = ConversationDriver(server, smoke_config).ask(
-            "Reply with one short sentence."
+            "Reply with one short sentence.", headers=headers
         )
     _assert_provider_product_stream(followup.events)
 
@@ -646,4 +647,4 @@ def _openai_auth_headers(smoke_config: SmokeConfig) -> dict[str, str]:
     token = smoke_config.settings.proxy_auth_token
     if token:
         headers["authorization"] = f"Bearer {token}"
-    return headers
+    return conversation_headers(headers)

{free_claude_code-6.3.1 → free_claude_code-6.3.2}/src/free_claude_code/providers/nvidia_nim/client.py

@@ -33,7 +33,6 @@ from .request_options import (
 )
 from .retry import (
     clone_body_without_chat_template,
-    clone_body_without_reasoning_budget,
     clone_body_without_reasoning_content,
 )
 from .tool_schema import (
@@ -61,10 +60,7 @@ class NvidiaNimChatBehavior(OpenAIChatBehavior):
 
     @property
     def reasoning_off_fields(self) -> tuple[tuple[str, ...], ...]:
-        return (
-            ("extra_body", "chat_template_kwargs", "thinking"),
-            ("extra_body", "chat_template_kwargs", "enable_thinking"),
-        )
+        return (("reasoning_effort",),)
 
     @property
     def normal_max_tokens(self) -> int | None:
@@ -118,17 +114,6 @@ class NvidiaNimChatBehavior(OpenAIChatBehavior):
             error_text = f"{error_text} {json.dumps(error_body, default=str)}"
         error_text = error_text.lower()
 
-        if _is_reasoning_budget_rejection(error_text) and (
-            bad_request_like or status_code == 500
-        ):
-            retry_body = clone_body_without_reasoning_budget(body)
-            if retry_body is None:
-                return None
-            logger.warning(
-                "NIM_STREAM: retrying without reasoning budget after upstream rejection"
-            )
-            return retry_body
-
         if not bad_request_like:
             return None
 
@@ -215,10 +200,3 @@ def _is_degraded_function(body: Mapping[str, Any]) -> bool:
         and function_id
         and state.strip() == _DEGRADED_FUNCTION_STATE
     )
-
-
-def _is_reasoning_budget_rejection(error_text: str) -> bool:
-    """Return whether NIM rejected optional thinking budget control."""
-    if "reasoning_budget" in error_text:
-        return True
-    return "thinking_token_budget" in error_text and "reasoning_config" in error_text

{free_claude_code-6.3.1 → free_claude_code-6.3.2}/src/free_claude_code/providers/nvidia_nim/request_options.py

@@ -6,14 +6,21 @@ from typing import Any
 from free_claude_code.config.nim import NimSettings
 from free_claude_code.core.anthropic import ReasoningReplayMode, set_if_not_none
 from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicy
+from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
 from free_claude_code.providers.openai_chat import (
+    NamedEffortReasoning,
     OpenAIChatRequestPolicy,
     build_openai_chat_request_body,
 )
 
 from .tool_schema import sanitize_nim_tool_schemas
 
+NIM_REASONING = NamedEffortReasoning(
+    tuple((effort, effort.value) for effort in ReasoningEffort),
+    disabled_value="none",
+    enabled_value="high",
+)
+
 NIM_REQUEST_POLICY = OpenAIChatRequestPolicy(
     provider_name="NIM",
     reasoning_replay=ReasoningReplayMode.REASONING_CONTENT,
@@ -106,14 +113,7 @@ def apply_nim_request_options(
         if not request_template_kwargs:
             extra_body.pop("chat_template_kwargs", None)
 
-    if reasoning.control is ReasoningControl.OFF or reasoning.requests_reasoning:
-        chat_template_kwargs = extra_body.setdefault("chat_template_kwargs", {})
-        if isinstance(chat_template_kwargs, dict):
-            enabled = reasoning.control is not ReasoningControl.OFF
-            chat_template_kwargs["thinking"] = enabled
-            chat_template_kwargs["enable_thinking"] = enabled
-            if enabled and (budget := reasoning.numeric_budget_tokens) is not None:
-                chat_template_kwargs["reasoning_budget"] = budget
+    NIM_REASONING.encode(body, reasoning)
 
     _set_extra(extra_body, "top_k", nim.top_k, ignore_value=-1)
     _set_extra(extra_body, "min_p", nim.min_p, ignore_value=0.0)

{free_claude_code-6.3.1 → free_claude_code-6.3.2}/src/free_claude_code/providers/nvidia_nim/retry.py

@@ -7,11 +7,6 @@ from typing import Any
 from free_claude_code.core.history_replay import reasoning_context
 
 
-def clone_body_without_reasoning_budget(body: dict[str, Any]) -> dict[str, Any] | None:
-    """Clone a request body and strip only reasoning_budget fields."""
-    return _clone_strip_extra_body(body, _strip_reasoning_budget_fields)
-
-
 def clone_body_without_chat_template(body: dict[str, Any]) -> dict[str, Any] | None:
     """Clone a request body and strip NIM chat-template control fields."""
     return _clone_strip_extra_body(body, _strip_chat_template_fields)
@@ -42,17 +37,6 @@ def _clone_strip_extra_body(
     return cloned_body
 
 
-def _strip_reasoning_budget_fields(extra_body: dict[str, Any]) -> bool:
-    removed = extra_body.pop("reasoning_budget", None) is not None
-    chat_template_kwargs = extra_body.get("chat_template_kwargs")
-    if (
-        isinstance(chat_template_kwargs, dict)
-        and chat_template_kwargs.pop("reasoning_budget", None) is not None
-    ):
-        removed = True
-    return removed
-
-
 def _strip_chat_template_fields(extra_body: dict[str, Any]) -> bool:
     removed = extra_body.pop("chat_template", None) is not None
     if extra_body.pop("chat_template_kwargs", None) is not None:

{free_claude_code-6.3.1 → free_claude_code-6.3.2}/tests/contracts/test_smoke_child_process.py

@@ -1,7 +1,11 @@
 import subprocess
+from contextlib import nullcontext
 from pathlib import Path
 from unittest.mock import MagicMock
 
+import httpx
+import pytest
+
 from free_claude_code.config.settings import Settings
 from smoke.lib import child_process
 from smoke.lib import e2e as smoke_e2e
@@ -12,10 +16,11 @@ from smoke.lib.child_process import (
     cmd_python_c,
     run_captured_text,
 )
-from smoke.lib.config import SmokeConfig
+from smoke.lib.config import ProviderModel, SmokeConfig
 from smoke.lib.e2e import ConversationDriver
 from smoke.lib.http import collect_message_stream
 from smoke.lib.server import RunningServer
+from smoke.product import test_provider_product_live as provider_smoke
 
 
 def test_fcc_server_command_uses_cli_entrypoint() -> None:
@@ -116,6 +121,141 @@ def test_conversation_driver_explicitly_requests_sse(
     assert turn.events[-1].event == "message_stop"
 
 
+def test_smoke_conversation_identity_survives_turns_and_tool_results(
+    monkeypatch, tmp_path: Path
+) -> None:
+    captured = []
+
+    def fake_stream(_method, _url, **kwargs):
+        captured.append(httpx.Headers(kwargs["headers"]))
+        return _FakeStreamResponse()
+
+    monkeypatch.setattr(smoke_e2e.httpx, "stream", fake_stream)
+    server, config = _running_server(tmp_path), _smoke_config(tmp_path)
+    conversation = ConversationDriver(server, config)
+    conversation.ask("First turn")
+    conversation.ask("Second turn")
+    conversation.stream(
+        {
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": "tool-1",
+                            "content": "done",
+                        }
+                    ],
+                }
+            ]
+        }
+    )
+    ConversationDriver(server, config).ask("Different conversation")
+
+    assert captured[0]["x-opencode-session"]
+    assert len({h["x-opencode-session"] for h in captured[:3]}) == 1
+    assert captured[3]["x-opencode-session"] != captured[0]["x-opencode-session"]
+    assert all(h["user-agent"].startswith("fcc-smoke/") for h in captured)
+
+
+@pytest.mark.parametrize(
+    "helper", [smoke_http.collect_message_stream, smoke_http.post_json]
+)
+def test_standalone_smoke_requests_identify_themselves_without_changing_auth(
+    monkeypatch, tmp_path: Path, helper
+) -> None:
+    captured = []
+
+    def capture(*args, **kwargs):
+        captured.append(httpx.Headers(kwargs["headers"]))
+        return _FakeStreamResponse()
+
+    monkeypatch.setattr(smoke_http.httpx, "stream", capture)
+    monkeypatch.setattr(smoke_http.httpx, "post", capture)
+    args: list[object] = [_running_server(tmp_path)]
+    if helper is smoke_http.post_json:
+        args.append("/v1/messages")
+    args += [{"messages": []}, _smoke_config(tmp_path)]
+    explicit = {
+        "Authorization": "Bearer explicit",
+        "X-OpenCode-Session": "caller",
+        "User-Agent": "caller/1.0",
+    }
+    helper(*args)
+    helper(*args)
+    helper(*args, headers=explicit)
+    helper(*args, headers={})
+
+    assert captured[0]["x-opencode-session"] != captured[1]["x-opencode-session"]
+    assert captured[0]["user-agent"].startswith("fcc-smoke/")
+    assert captured[2] == httpx.Headers(explicit)
+    assert "authorization" not in captured[3]
+    assert explicit["X-OpenCode-Session"] == "caller"
+
+
+def test_provider_responses_smoke_sends_conversation_identity(monkeypatch, tmp_path):
+    captured = []
+
+    class ResponsesStream(_FakeStreamResponse):
+        def iter_lines(self):
+            return iter(
+                (
+                    "event: response.created",
+                    "data: {}",
+                    "",
+                    "event: response.output_text.delta",
+                    'data: {"delta":"ok"}',
+                    "",
+                    "event: response.completed",
+                    "data: {}",
+                    "",
+                )
+            )
+
+    def capture(*args, **kwargs):
+        captured.append(httpx.Headers(kwargs["headers"]))
+        return ResponsesStream()
+
+    monkeypatch.setattr(
+        provider_smoke,
+        "_server_for_provider",
+        lambda *args: nullcontext(_running_server(tmp_path)),
+    )
+    monkeypatch.setattr(provider_smoke.httpx, "stream", capture)
+    model = ProviderModel("opencode_go", "opencode_go/minimax-m2.7", "test")
+    for _ in range(2):
+        provider_smoke.test_provider_codex_responses_text_e2e(
+            _smoke_config(tmp_path), model
+        )
+    assert captured[0]["x-opencode-session"] != captured[1]["x-opencode-session"]
+    assert all(h["user-agent"].startswith("fcc-smoke/") for h in captured)
+
+
+def test_disconnect_smoke_reuses_identity_for_followup(monkeypatch, tmp_path):
+    captured = []
+
+    def capture(*args, **kwargs):
+        captured.append(httpx.Headers(kwargs["headers"]))
+        return _FakeStreamResponse()
+
+    monkeypatch.setattr(
+        provider_smoke,
+        "_server_for_provider",
+        lambda *args: nullcontext(_running_server(tmp_path)),
+    )
+    monkeypatch.setattr(provider_smoke.httpx, "stream", capture)
+    monkeypatch.setattr(
+        provider_smoke.httpx, "get", lambda *args, **kwargs: httpx.Response(200)
+    )
+    model = ProviderModel("opencode_go", "opencode_go/minimax-m2.7", "test")
+    provider_smoke._scenario_disconnect(_smoke_config(tmp_path), model)
+
+    assert len(captured) == 2
+    assert captured[0]["x-opencode-session"] == captured[1]["x-opencode-session"]
+    assert all(h["user-agent"].startswith("fcc-smoke/") for h in captured)
+
+
 def test_run_captured_text_uses_utf8_replacement(monkeypatch, tmp_path: Path) -> None:
     calls: dict[str, object] = {}
 

{free_claude_code-6.3.1 → free_claude_code-6.3.2}/tests/providers/test_nvidia_nim.py

@@ -16,7 +16,7 @@ from free_claude_code.core.history_replay import (
     encode_replay,
 )
 from free_claude_code.core.openai_responses.models import OpenAIResponsesRequest
-from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
+from free_claude_code.core.reasoning import ReasoningPolicy
 from free_claude_code.providers.admission import UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS
 from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
 from free_claude_code.providers.nvidia_nim.client import _PROFILE as NIM_PROFILE
@@ -165,7 +165,6 @@ def _alias_events():
         ("responses", None),
         ("messages", "chat_template"),
         ("responses", "chat_template"),
-        ("messages", "reasoning_budget"),
         ("messages", "reasoning_content"),
     ],
 )
@@ -398,10 +397,8 @@ async def test_build_request_body(provider_config):
     assert body["messages"][0]["content"] == "System prompt"
 
     assert "extra_body" in body
-    ctk = body["extra_body"]["chat_template_kwargs"]
-    assert ctk["thinking"] is True
-    assert ctk["enable_thinking"] is True
-    assert "reasoning_budget" not in ctk
+    assert body["reasoning_effort"] == "high"
+    assert "chat_template_kwargs" not in body["extra_body"]
     assert "reasoning_budget" not in body["extra_body"]
 
 
@@ -454,10 +451,8 @@ def test_responses_request_uses_nim_chat_policy(provider_config):
     assert parameters["properties"] == {"_fcc_arg_type": {"type": "string"}}
     extra_body = body["extra_body"]
     assert isinstance(extra_body, dict)
-    assert extra_body["chat_template_kwargs"] == {
-        "thinking": True,
-        "enable_thinking": True,
-    }
+    assert body["reasoning_effort"] == "high"
+    assert "chat_template_kwargs" not in extra_body
 
 
 @pytest.mark.asyncio
@@ -473,10 +468,8 @@ async def test_build_request_body_encodes_explicit_reasoning_off(
     body = provider._chat._build_request_body(req, reasoning=REASONING_OFF)
 
     extra = body.get("extra_body", {})
-    assert extra["chat_template_kwargs"] == {
-        "thinking": False,
-        "enable_thinking": False,
-    }
+    assert body["reasoning_effort"] == "none"
+    assert "chat_template_kwargs" not in extra
     assert "reasoning_budget" not in extra
 
 
@@ -713,10 +706,7 @@ async def test_stream_messages_retries_without_chat_template(provider_config):
     second_extra = mock_create.call_args_list[1].kwargs["extra_body"]
 
     assert first_extra["chat_template"] == "custom_template"
-    assert first_extra["chat_template_kwargs"] == {
-        "thinking": True,
-        "enable_thinking": True,
-    }
+    assert "chat_template_kwargs" not in first_extra
     assert "reasoning_budget" not in first_extra
 
     assert "chat_template" not in second_extra
@@ -737,7 +727,10 @@ async def test_stream_messages_retries_without_chat_template_kwargs_issue_993(
         nim_settings=NimSettings(),
         admission=immediate_admission(),
     )
-    req = make_request(model="mistralai/mistral-small-4-119b-2603")
+    req = make_request(
+        model="mistralai/mistral-small-4-119b-2603",
+        extra_body={"chat_template_kwargs": {"custom": "value"}},
+    )
 
     mock_chunk = MagicMock()
     mock_chunk.choices = [
@@ -770,10 +763,7 @@ async def test_stream_messages_retries_without_chat_template_kwargs_issue_993(
     second_kwargs = mock_create.call_args_list[1].kwargs
 
     assert "chat_template" not in first_extra
-    assert first_extra["chat_template_kwargs"] == {
-        "thinking": True,
-        "enable_thinking": True,
-    }
+    assert first_extra["chat_template_kwargs"] == {"custom": "value"}
     second_extra = second_kwargs.get("extra_body") or {}
     assert "chat_template" not in second_extra
     assert "chat_template_kwargs" not in second_extra
@@ -1330,95 +1320,6 @@ async def test_stream_messages_task_tool_still_forces_background_false(nim_provi
     assert json.loads(deltas[0])["run_in_background"] is False
 
 
-@pytest.mark.asyncio
-async def test_stream_messages_retries_without_reasoning_budget(nim_provider):
-    req = make_request()
-
-    mock_chunk = MagicMock()
-    mock_chunk.choices = [
-        MagicMock(
-            delta=MagicMock(content="Recovered", reasoning_content=""),
-            finish_reason="stop",
-        )
-    ]
-    mock_chunk.usage = MagicMock(completion_tokens=5)
-
-    async def mock_stream():
-        yield mock_chunk
-
-    error = _make_bad_request_error("Unsupported field: reasoning_budget")
-
-    with patch.object(
-        nim_provider._client.chat.completions, "create", new_callable=AsyncMock
-    ) as mock_create:
-        mock_create.side_effect = [error, SDKStreamDouble(mock_stream())]
-
-        events = [
-            e
-            async for e in nim_provider.stream_messages(
-                req,
-                reasoning=ReasoningPolicy.on(effort=ReasoningEffort.XHIGH),
-            )
-        ]
-
-    assert mock_create.await_count == 2
-    first_call = mock_create.await_args_list[0].kwargs
-    second_call = mock_create.await_args_list[1].kwargs
-    assert first_call["extra_body"]["chat_template_kwargs"]["reasoning_budget"] == 4096
-    assert "reasoning_budget" not in second_call["extra_body"]
-    assert "reasoning_budget" not in second_call["extra_body"]["chat_template_kwargs"]
-    assert second_call["extra_body"]["chat_template_kwargs"]["enable_thinking"] is True
-    assert any("Recovered" in event for event in events)
-    assert any("message_stop" in event for event in events)
-
-
-@pytest.mark.asyncio
-async def test_stream_messages_retries_without_budget_for_thinking_token_error(
-    nim_provider,
-):
-    req = make_request(model="meta/llama-3.3-70b-instruct")
-
-    mock_chunk = MagicMock()
-    mock_chunk.choices = [
-        MagicMock(
-            delta=MagicMock(content="Recovered", reasoning_content=""),
-            finish_reason="stop",
-        )
-    ]
-    mock_chunk.usage = MagicMock(completion_tokens=5)
-
-    async def mock_stream():
-        yield mock_chunk
-
-    error = _make_internal_server_error(
-        "ValueError: thinking_token_budget is set but reasoning_config is not "
-        "configured. Please set --reasoning-config to use thinking_token_budget."
-    )
-
-    with patch.object(
-        nim_provider._client.chat.completions, "create", new_callable=AsyncMock
-    ) as mock_create:
-        mock_create.side_effect = [error, SDKStreamDouble(mock_stream())]
-
-        events = [
-            e
-            async for e in nim_provider.stream_messages(
-                req, reasoning=ReasoningPolicy.on(budget_tokens=77)
-            )
-        ]
-
-    assert mock_create.await_count == 2
-    first_call = mock_create.await_args_list[0].kwargs
-    second_call = mock_create.await_args_list[1].kwargs
-    assert first_call["extra_body"]["chat_template_kwargs"]["reasoning_budget"] == 77
-    assert "reasoning_budget" not in second_call["extra_body"]
-    assert "reasoning_budget" not in second_call["extra_body"]["chat_template_kwargs"]
-    assert second_call["extra_body"]["chat_template_kwargs"]["thinking"] is True
-    assert second_call["extra_body"]["chat_template_kwargs"]["enable_thinking"] is True
-    assert any("Recovered" in event for event in events)
-    assert any("message_stop" in event for event in events)
-
-
 @pytest.mark.asyncio
 async def test_stream_messages_retries_without_reasoning_content(nim_provider):
     req = make_request(