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

Use six effort options in Code Sessions (#1715)

Ali Khokhar3d5b9d800795
diff --git a/e2e/test_code_sessions.py b/e2e/test_code_sessions.py
index 8dcb18aa..fd9ff243 100644
--- a/e2e/test_code_sessions.py
+++ b/e2e/test_code_sessions.py
@@ -782,7 +782,30 @@ def send_from_other_client(page, url, text):
return response.json()["id"]
-def test_model_default_clears_effort_when_all_choices_disappear(
[email protected]("choice", ["off", "low", "medium", "high", "xhigh", "max"])
+def test_effort_options_persist_and_reach_the_harness(
+ page, admin_base_url, tmp_path, code_control, choice
+):
+ create_session(page, admin_base_url, tmp_path)
+ effort = page.get_by_role("combobox", name="Effort", exact=True)
+ expect(effort.locator("option")).to_have_text(
+ ["off", "low", "medium", "high", "xhigh", "max"]
+ )
+ expect(effort).to_have_value("medium")
+ with page.expect_response(
+ lambda response: (
+ response.request.method == "PATCH" and "/api/code/sessions/" in response.url
+ )
+ ) as changed:
+ effort.select_option(choice)
+ assert changed.value.json()["reasoning_effort"] == choice
+ page.reload()
+ expect(effort).to_have_value(choice)
+ send(page, "Use this effort")
+ assert code_control.connection().efforts == [choice]
+
+
+def test_off_clears_effort_when_reasoning_becomes_unavailable(
page, context, admin_base_url, tmp_path, code_control
):
url = create_session(page, admin_base_url, tmp_path)
@@ -790,12 +813,15 @@ def test_model_default_clears_effort_when_all_choices_disappear(
effort.select_option("high")
expect(effort).to_be_enabled()
page.locator("#codeComposer").fill("Preserve this draft")
- code_control.harness.efforts = ()
- code_control.harness.default_effort = None
+ code_control.harness.efforts = ("off",)
+ code_control.harness.default_effort = "off"
page.evaluate("window.CodeSessions.refresh()")
expect(page.locator("#codeComposerStatus")).to_contain_text("unavailable")
expect(effort).to_have_value("high")
- expect(effort.locator("option:checked")).to_have_text("high (unavailable)")
+ expect(effort.locator("option:checked")).to_have_text("high")
+ expect(effort.locator("option:disabled")).to_have_text(
+ ["low", "medium", "high", "xhigh", "max"]
+ )
expect(page.locator("#codeSend")).to_be_disabled()
expect(effort).to_be_enabled()
patches = []
@@ -812,24 +838,22 @@ def test_model_default_clears_effort_when_all_choices_disappear(
response.request.method == "PATCH" and "/api/code/sessions/" in response.url
)
) as reset:
- effort.select_option("")
- assert reset.value.json()["reasoning_effort"] is None
- assert len(patches) == 1 and patches[0]["reasoning_effort"] is None
- expect(effort).to_be_disabled()
+ effort.select_option("off")
+ assert reset.value.json()["reasoning_effort"] == "off"
+ assert len(patches) == 1 and patches[0]["reasoning_effort"] == "off"
expect(page.locator("#codeComposerStatus")).not_to_contain_text("unavailable")
expect(page.locator("#codeSend")).to_be_enabled()
page.reload()
- expect(effort).to_have_value("")
- expect(effort).to_be_disabled()
+ expect(effort).to_have_value("off")
expect(page.locator("#codeComposer")).to_have_value("Preserve this draft")
second = context.new_page()
try:
second.goto(url)
- expect(second.locator("#codeReasoning")).to_have_value("")
+ expect(second.locator("#codeReasoning")).to_have_value("off")
expect(second.locator("#codeModel")).to_have_value("provider/model")
page.locator("#codeSend").click()
connection = code_control.connection()
- assert connection.efforts == [None]
+ assert connection.efforts == ["off"]
assert connection.inputs[0][1:] == ("Preserve this draft", "provider/model")
finally:
second.close()
@@ -1087,8 +1111,8 @@ def test_model_effort_picker_syncs_tabs_and_keeps_missing_selection(
expect(page.locator("#codeModel")).to_be_disabled()
expect(second.locator("#codeReasoning")).to_be_disabled()
code_control.run(connection.finish("turn-1"))
- page.locator("#codeReasoning").select_option("")
- expect(second.locator("#codeReasoning")).to_have_value("")
+ page.locator("#codeReasoning").select_option("medium")
+ expect(second.locator("#codeReasoning")).to_have_value("medium")
page.get_by_role("textbox", name="Message", exact=True).fill("Preserve me")
code_control.harness.configurations.pop("provider/other")
if refresh_first:
diff --git a/pyproject.toml b/pyproject.toml
index 7367550d..37319f25 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
[project]
name = "free-claude-code"
-version = "6.1.1"
+version = "6.1.2"
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/api/admin_static/code_sessions.js b/src/free_claude_code/api/admin_static/code_sessions.js
index 6c28cc51..3d57cee4 100644
--- a/src/free_claude_code/api/admin_static/code_sessions.js
+++ b/src/free_claude_code/api/admin_static/code_sessions.js
@@ -716,7 +716,7 @@
record.session.reasoning_effort &&
!model.reasoning_efforts.includes(record.session.reasoning_effort)
)
- return "Selected thinking effort is unavailable. Choose another effort or Model default.";
+ return "Selected effort is unavailable. Choose another effort.";
return "";
}
@@ -783,7 +783,7 @@
[],
"",
(value) => {
- void updateSettings({ reasoning_effort: value || null });
+ void updateSettings({ reasoning_effort: value });
},
);
controls.append(modelControl.group, reasoningControl.group);
@@ -1035,21 +1035,15 @@
!catalogLoaded;
modelControl.update(record?.session?.model || "", disabled);
const model = catalog.find((model) => model.id === record?.session?.model),
- effort = record?.session?.reasoning_effort;
- const options = [
- [
- "",
- model?.default_reasoning_effort
- ? `Model default (${model.default_reasoning_effort})`
- : "Model default",
- ],
- ...(model?.reasoning_efforts || []).map((value) => [value, value]),
- ];
- if (effort && !model?.reasoning_efforts.includes(effort))
- options.push([effort, `${effort} (unavailable)`]);
- reasoningControl.update(options, effort || "");
- reasoningControl.select.disabled =
- disabled || !model || (!model.reasoning_efforts.length && !effort);
+ effort =
+ record?.session?.reasoning_effort || model?.default_reasoning_effort || "off";
+ const options = ["off", "low", "medium", "high", "xhigh", "max"].map(
+ (value) => [value, value],
+ );
+ reasoningControl.update(options, effort);
+ for (const option of reasoningControl.select.options)
+ option.disabled = !model?.reasoning_efforts.includes(option.value);
+ reasoningControl.select.disabled = disabled || !model;
root.querySelector("#codeComposerStatus").textContent =
record?.session?.error ||
selectionError(record) ||
diff --git a/src/free_claude_code/api/admin_static/session_ui.js b/src/free_claude_code/api/admin_static/session_ui.js
index d9440974..f867ac9d 100644
--- a/src/free_claude_code/api/admin_static/session_ui.js
+++ b/src/free_claude_code/api/admin_static/session_ui.js
@@ -133,7 +133,7 @@
};
update(options, value);
select.addEventListener("change", () => onChange(select.value));
- group.append(node("span", "", "Thinking"), select);
+ group.append(node("span", "", "Effort"), select);
return { group, select, update };
}
function composer(id, draft, placeholder, onInput, onSend, onStop) {
diff --git a/src/free_claude_code/application/code_sessions/service.py b/src/free_claude_code/application/code_sessions/service.py
index 3aae0609..12eb9cf5 100644
--- a/src/free_claude_code/application/code_sessions/service.py
+++ b/src/free_claude_code/application/code_sessions/service.py
@@ -368,7 +368,7 @@ class CodeService:
effort = None
if effort is not None and effort not in entry.reasoning_efforts:
raise CodeValidationError(
- "This reasoning effort is unavailable. Choose another effort or Model default."
+ "This effort is unavailable. Choose another effort."
)
updates.update(model=model, reasoning_effort=effort)
session = await self._store.update_settings(
diff --git a/src/free_claude_code/cli/launchers/codex_model_catalog.py b/src/free_claude_code/cli/launchers/codex_model_catalog.py
index f9d34cfb..4bf7663b 100644
--- a/src/free_claude_code/cli/launchers/codex_model_catalog.py
+++ b/src/free_claude_code/cli/launchers/codex_model_catalog.py
@@ -11,6 +11,7 @@ from free_claude_code.core.model_capabilities import ModelInputModality
from .model_catalog import ClientModel
SUPPORTED_REASONING_LEVELS: list[JsonObject] = [
+ {"effort": "none", "description": "Turn reasoning off"},
{"effort": "low", "description": "Fast responses with lighter reasoning"},
{
"effort": "medium",
@@ -21,6 +22,7 @@ SUPPORTED_REASONING_LEVELS: list[JsonObject] = [
"effort": "xhigh",
"description": "Extra high reasoning depth for complex problems",
},
+ {"effort": "max", "description": "Maximum reasoning effort"},
]
CODEX_BASE_INSTRUCTIONS = (
diff --git a/src/free_claude_code/runtime/codex_app_server.py b/src/free_claude_code/runtime/codex_app_server.py
index c98899d2..e148b97f 100644
--- a/src/free_claude_code/runtime/codex_app_server.py
+++ b/src/free_claude_code/runtime/codex_app_server.py
@@ -168,8 +168,9 @@ class CodexAppServer:
"model": model,
}
if self._reasoning.get(selection.model, True):
- params["summary"] = "auto"
- params["effort"] = selection.reasoning_effort
+ off = selection.reasoning_effort == "off"
+ params["summary"] = "none" if off else "auto"
+ params["effort"] = "none" if off else selection.reasoning_effort
result = await self.rpc("turn/start", params)
turn_id = string_value(object_value(result.get("turn")).get("id"))
if not turn_id:
@@ -594,7 +595,7 @@ class CodexHarnessFactory:
and reasoning_effort not in option.reasoning_efforts
):
raise CodeValidationError(
- "This reasoning effort is unavailable. Choose another effort or Model default."
+ "This effort is unavailable. Choose another effort."
)
effort = reasoning_effort or option.default_reasoning_effort
fingerprints = {
@@ -631,15 +632,19 @@ class CodexHarnessFactory:
def _model_option(model: str, entry: JsonObject) -> CodeModel:
+ efforts = tuple(
+ string_value(object_value(level).get("effort"))
+ for level in array_value(entry.get("supported_reasoning_levels"))
+ )
return CodeModel(
id=model,
display_name=string_value(entry.get("display_name")) or model,
reasoning_efforts=tuple(
- string_value(object_value(level).get("effort"))
- for level in array_value(entry.get("supported_reasoning_levels"))
- ),
+ "off" if effort == "none" else effort for effort in efforts
+ )
+ or ("off",),
default_reasoning_effort=string_value(entry.get("default_reasoning_level"))
- or None,
+ or "off",
)
diff --git a/tests/code_sessions_support.py b/tests/code_sessions_support.py
index 0116700b..9a339d93 100644
--- a/tests/code_sessions_support.py
+++ b/tests/code_sessions_support.py
@@ -27,7 +27,7 @@ class FakeHarness:
self.connections: list[FakeConnection] = []
self.model = "provider/model"
self.configurations = {self.model: "capabilities-1"}
- self.efforts = ("low", "medium", "high", "xhigh")
+ self.efforts = ("off", "low", "medium", "high", "xhigh", "max")
self.default_effort = "medium"
self.creation_gate = asyncio.Event()
self.start_gate = asyncio.Event()
diff --git a/tests/runtime/test_codex_app_server.py b/tests/runtime/test_codex_app_server.py
index 06cc987f..a03f0b0e 100644
--- a/tests/runtime/test_codex_app_server.py
+++ b/tests/runtime/test_codex_app_server.py
@@ -181,12 +181,15 @@ async def test_turn_start_resets_sticky_effort_and_preserves_client_identity(
monkeypatch.setattr(native, "rpc", rpc)
harness = FakeHarness()
- for effort in (None, "high", None):
+ for effort in (None, "high", "off", "max", None):
await native.start_turn(
"hello", harness.prepare("provider/model", effort), "operation"
)
assert [request.get("effort") for request in requests] == (
- ["medium", "high", "medium"] if reasoning else [None, None, None]
+ ["medium", "high", "none", "max", "medium"] if reasoning else [None] * 5
+ )
+ assert [request.get("summary") for request in requests] == (
+ ["auto", "auto", "none", "auto", "auto"] if reasoning else [None] * 5
)
assert all(
request["clientUserMessageId"] == "operation"
diff --git a/tests/runtime/test_codex_catalog.py b/tests/runtime/test_codex_catalog.py
index 99fdfd55..6e2b57e0 100644
--- a/tests/runtime/test_codex_catalog.py
+++ b/tests/runtime/test_codex_catalog.py
@@ -111,12 +111,32 @@ def test_code_picker_and_native_selection_use_the_same_advertised_efforts():
advertised = factory.catalog()
assert advertised.default_model == "nvidia_nim/configured"
model = advertised.models[1]
+ assert model.reasoning_efforts == ("off", "low", "medium", "high", "xhigh", "max")
selected = factory.prepare(model.id, None)
assert selected.model == model.id
assert selected.context.settings.model == model.id
assert selected.reasoning_effort == model.default_reasoning_effort == "medium"
- assert factory.prepare(model.id, "high").reasoning_effort == "high"
+ for effort in model.reasoning_efforts:
+ assert factory.prepare(model.id, effort).reasoning_effort == effort
with pytest.raises(CodeValidationError, match="effort"):
factory.prepare(model.id, "unsupported")
with pytest.raises(CodeValidationError, match="model"):
factory.prepare("missing/model", None)
+
+
+def test_non_reasoning_model_off_selection_is_available():
+ runtime = FakeRequestRuntime(
+ settings=Settings().model_copy(update={"model": "nvidia_nim/configured"}),
+ cached_infos=(
+ ProviderModelInfo("open_router/text-only", supports_thinking=False),
+ ),
+ )
+ factory = CodexHarnessFactory(runtime, binary="codex")
+ model = next(
+ entry
+ for entry in factory.catalog().models
+ if entry.id == "open_router/text-only"
+ )
+ assert model.reasoning_efforts == ("off",)
+ assert model.default_reasoning_effort == "off"
+ assert factory.prepare(model.id, "off").reasoning_effort == "off"
diff --git a/uv.lock b/uv.lock
index 42d7a95e..416f7dab 100644
--- a/uv.lock
+++ b/uv.lock
@@ -598,7 +598,7 @@ wheels = [
[[package]]
name = "free-claude-code"
-version = "6.1.1"
+version = "6.1.2"
source = { editable = "." }
dependencies = [
{ name = "aiohttp" },