Skip to content

Open-source SEO, GEO, and marketing skills for AI agents.

feat(chat): add dynamic Codex effort controls

Yuting Zhong0da3553b6fb5
diff --git a/notfair/src/app/api/chat/route.test.ts b/notfair/src/app/api/chat/route.test.ts
new file mode 100644
index 00000000..35fcca53
--- /dev/null
+++ b/notfair/src/app/api/chat/route.test.ts
@@ -0,0 +1,146 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import type {
+ HarnessAdapter,
+ HarnessExecuteContext,
+ HarnessModelOption,
+} from "@/server/adapters/types";
+
+const mocks = vi.hoisted(() => ({
+ getProject: vi.fn(),
+ getActiveProject: vi.fn(),
+ resolveAgentBySlug: vi.fn(),
+ requireAdapter: vi.fn(),
+ workspaceDirFor: vi.fn(() => "/tmp/notfair-agent"),
+ getOrCreateSession: vi.fn(),
+ appendTranscriptEvent: vi.fn(),
+ touchSession: vi.fn(),
+ registerLiveTurn: vi.fn(),
+ releaseLiveTurn: vi.fn(),
+}));
+
+vi.mock("@/server/active-project", () => ({
+ getActiveProject: mocks.getActiveProject,
+}));
+vi.mock("@/server/db/projects", () => ({ getProject: mocks.getProject }));
+vi.mock("@/server/agent-meta", () => ({
+ resolveAgentBySlug: mocks.resolveAgentBySlug,
+}));
+vi.mock("@/server/adapters/registry", () => ({
+ requireAdapter: mocks.requireAdapter,
+}));
+vi.mock("@/server/agents/provisioning", () => ({
+ workspaceDirFor: mocks.workspaceDirFor,
+}));
+vi.mock("@/server/sessions", () => ({
+ getOrCreateSession: mocks.getOrCreateSession,
+ appendTranscriptEvent: mocks.appendTranscriptEvent,
+ touchSession: mocks.touchSession,
+}));
+vi.mock("@/server/sessions/live-turns", () => ({
+ registerLiveTurn: mocks.registerLiveTurn,
+ releaseLiveTurn: mocks.releaseLiveTurn,
+}));
+
+import { POST } from "./route";
+
+const models: HarnessModelOption[] = [
+ {
+ value: "gpt-dynamic",
+ label: "Dynamic model",
+ is_default: true,
+ default_reasoning_effort: "low",
+ reasoning_efforts: [
+ { value: "low", label: "Low" },
+ { value: "high", label: "High" },
+ ],
+ },
+];
+
+function request(body: unknown) {
+ return new Request("http://localhost/api/chat", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(body),
+ });
+}
+
+describe("POST /api/chat reasoning effort", () => {
+ let executeContext: HarnessExecuteContext | null;
+ let adapter: Pick<HarnessAdapter, "listModels" | "execute">;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ executeContext = null;
+ adapter = {
+ listModels: vi.fn(async () => models),
+ execute: vi.fn(async function* (ctx: HarnessExecuteContext) {
+ executeContext = ctx;
+ }),
+ };
+ mocks.getProject.mockReturnValue({
+ slug: "acme",
+ harness_adapter: "codex-local",
+ });
+ mocks.resolveAgentBySlug.mockResolvedValue({ agent_id: "goal-agent" });
+ mocks.requireAdapter.mockReturnValue(adapter);
+ mocks.getOrCreateSession.mockReturnValue({
+ id: "session-1",
+ harness_session_id: null,
+ });
+ mocks.registerLiveTurn.mockReturnValue(new AbortController());
+ });
+
+ it("validates and forwards a provider-supported effort without forcing a model", async () => {
+ const response = await POST(
+ request({
+ project: "acme",
+ agent: "goal-1",
+ message: "hello",
+ reasoning_effort: "high",
+ }),
+ );
+ await response.text();
+
+ expect(response.status).toBe(200);
+ expect(adapter.listModels).toHaveBeenCalledOnce();
+ expect(executeContext).toMatchObject({
+ model: null,
+ reasoningEffort: "high",
+ });
+ });
+
+ it("rejects an effort the selected model did not publish", async () => {
+ const response = await POST(
+ request({
+ project: "acme",
+ agent: "goal-1",
+ message: "hello",
+ reasoning_effort: "ultra-secret",
+ }),
+ );
+
+ expect(response.status).toBe(400);
+ await expect(response.json()).resolves.toMatchObject({
+ error: "Unknown reasoning effort 'ultra-secret' for model 'gpt-dynamic'",
+ });
+ expect(adapter.execute).not.toHaveBeenCalled();
+ });
+
+ it("returns a 400 for a non-string effort instead of throwing", async () => {
+ const response = await POST(
+ request({
+ project: "acme",
+ agent: "goal-1",
+ message: "hello",
+ reasoning_effort: 42,
+ }),
+ );
+
+ expect(response.status).toBe(400);
+ await expect(response.json()).resolves.toEqual({
+ error: "reasoning_effort must be a string",
+ });
+ expect(adapter.listModels).not.toHaveBeenCalled();
+ });
+});
diff --git a/notfair/src/app/api/chat/route.ts b/notfair/src/app/api/chat/route.ts
index 862d629a..45a3fd0c 100644
--- a/notfair/src/app/api/chat/route.ts
+++ b/notfair/src/app/api/chat/route.ts
@@ -34,6 +34,8 @@ type ChatPostBody = {
* else is a 400 (values become CLI spawn args, so no passthrough).
*/
model?: string;
+ /** Provider-supported per-turn reasoning effort override. */
+ reasoning_effort?: string;
};
export async function POST(request: Request) {
@@ -70,15 +72,44 @@ export async function POST(request: Request) {
// Whitelist the model against the adapter's provider-fed list — the
// value becomes a CLI spawn arg, so arbitrary client strings never
// pass through unchecked.
+ if (body.model !== undefined && typeof body.model !== "string") {
+ return NextResponse.json({ error: "model must be a string" }, { status: 400 });
+ }
+ if (
+ body.reasoning_effort !== undefined &&
+ typeof body.reasoning_effort !== "string"
+ ) {
+ return NextResponse.json(
+ { error: "reasoning_effort must be a string" },
+ { status: 400 },
+ );
+ }
const model = body.model?.trim() || null;
- if (model) {
+ const reasoningEffort = body.reasoning_effort?.trim() || null;
+ if (model || reasoningEffort) {
const available = await requireAdapter(project.harness_adapter).listModels();
- if (!available.some((m) => m.value === model)) {
+ if (model && !available.some((m) => m.value === model)) {
return NextResponse.json(
{ error: `Unknown model '${model}' for adapter '${project.harness_adapter}'` },
{ status: 400 },
);
}
+ const selectedModel = model
+ ? available.find((option) => option.value === model)
+ : available.find((option) => option.is_default) ?? available[0];
+ if (
+ reasoningEffort &&
+ !selectedModel?.reasoning_efforts?.some(
+ (option) => option.value === reasoningEffort,
+ )
+ ) {
+ return NextResponse.json(
+ {
+ error: `Unknown reasoning effort '${reasoningEffort}' for model '${selectedModel?.value ?? "default"}'`,
+ },
+ { status: 400 },
+ );
+ }
}
const label =
@@ -131,6 +162,7 @@ export async function POST(request: Request) {
threadId: session.id,
harnessSessionId: session.harness_session_id,
model,
+ reasoningEffort,
signal: ctrl.signal,
})) {
if (evt.kind === "session") {
diff --git a/notfair/src/components/chat/composer.test.tsx b/notfair/src/components/chat/composer.test.tsx
index 4aca7382..6f8668e0 100644
--- a/notfair/src/components/chat/composer.test.tsx
+++ b/notfair/src/components/chat/composer.test.tsx
@@ -28,8 +28,10 @@ vi.mock("@/components/ui/dropdown-menu", () => ({
DropdownMenu: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
DropdownMenuTrigger: ({ children }: { children: React.ReactNode }) => <>{children}</>,
DropdownMenuContent: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
- DropdownMenuRadioGroup: ({ children, value }: { children: React.ReactNode; value: string }) => <div data-value={value}>{children}</div>,
- DropdownMenuRadioItem: ({ children, value }: { children: React.ReactNode; value: string }) => <span data-value={value}>{children}</span>,
+ DropdownMenuLabel: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
+ DropdownMenuSeparator: () => <hr />,
+ DropdownMenuRadioGroup: ({ children, value }: { children: React.ReactNode; value: string }) => <div data-testid="radio-group" data-value={value}>{children}</div>,
+ DropdownMenuRadioItem: ({ children, value }: { children: React.ReactNode; value: string }) => <span data-testid="radio-item" data-value={value}>{children}</span>,
}));
import { ChatComposer } from "./composer";
@@ -39,7 +41,9 @@ const props = {
sendingChat: false,
placeholder: "Message agent",
model: "",
+ reasoningEffort: "",
onPickModel: vi.fn(),
+ onPickReasoningEffort: vi.fn(),
onSubmit: vi.fn(),
onStop: vi.fn(),
};
@@ -87,11 +91,38 @@ it("shows model labels for selected, default, and stale values", () => {
{ value: "deep", label: "Deep" },
];
const { rerender } = render(<ChatComposer {...props} modelOptions={options} model="deep" />);
- expect(screen.getByRole("button", { name: "Model" })).toHaveTextContent("Deep");
+ expect(screen.getByRole("button", { name: "Model and effort" })).toHaveTextContent("Deep");
rerender(<ChatComposer {...props} modelOptions={options} model="missing" />);
- expect(screen.getByRole("button", { name: "Model" })).toHaveTextContent("Fast");
+ expect(screen.getByRole("button", { name: "Model and effort" })).toHaveTextContent("Fast");
rerender(<ChatComposer {...props} modelOptions={[{ value: "x", label: "X" }]} model="" />);
- expect(screen.getByRole("button", { name: "Model" })).toHaveTextContent("Default");
+ expect(screen.getByRole("button", { name: "Model and effort" })).toHaveTextContent("Default");
+});
+
+it("renders the provider default model once and exposes its dynamic effort choices", () => {
+ const options = [
+ {
+ value: "fast",
+ label: "Fast",
+ is_default: true,
+ default_reasoning_effort: "low",
+ reasoning_efforts: [
+ { value: "low", label: "Low", description: "Faster" },
+ { value: "high", label: "High", description: "Deeper" },
+ ],
+ },
+ { value: "deep", label: "Deep" },
+ ];
+
+ render(<ChatComposer {...props} modelOptions={options} />);
+
+ expect(screen.queryByText("Fast (default)")).not.toBeInTheDocument();
+ const items = screen.getAllByTestId("radio-item");
+ expect(items.filter((item) => item.textContent === "Fast")).toHaveLength(1);
+ expect(items.filter((item) => item.textContent === "Low")).toHaveLength(1);
+ expect(items.filter((item) => item.textContent === "High")).toHaveLength(1);
+ expect(screen.getByRole("button", { name: "Model and effort" })).toHaveTextContent(
+ "Fast · Low",
+ );
});
it("navigates slash matches with arrows and inserts via Tab", () => {
diff --git a/notfair/src/components/chat/composer.tsx b/notfair/src/components/chat/composer.tsx
index c59ab3f3..ddb3986f 100644
--- a/notfair/src/components/chat/composer.tsx
+++ b/notfair/src/components/chat/composer.tsx
@@ -6,8 +6,10 @@ import { ArrowUp, ChevronDown, StopCircle } from "lucide-react";
import {
DropdownMenu,
DropdownMenuContent,
+ DropdownMenuLabel,
DropdownMenuRadioGroup,
DropdownMenuRadioItem,
+ DropdownMenuSeparator,
DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu";
import { RunningDot } from "@/components/running-dot";
@@ -17,7 +19,17 @@ import {
type SlashCommand,
} from "@/lib/slash-commands";
-export type ModelOption = { value: string; label: string; is_default?: boolean };
+export type ModelOption = {
+ value: string;
+ label: string;
+ is_default?: boolean;
+ reasoning_efforts?: Array<{
+ value: string;
+ label: string;
+ description?: string;
+ }>;
+ default_reasoning_effort?: string;
+};
/**
* The chat composer: one floating rounded well with a borderless
@@ -35,7 +47,9 @@ export function ChatComposer({
placeholder,
modelOptions = [],
model,
+ reasoningEffort,
onPickModel,
+ onPickReasoningEffort,
onSubmit,
onStop,
}: {
@@ -47,7 +61,9 @@ export function ChatComposer({
placeholder: string;
modelOptions?: ModelOption[];
model: string;
+ reasoningEffort: string;
onPickModel: (value: string) => void;
+ onPickReasoningEffort: (value: string) => void;
/** Dispatch a user submission (slash routing happens upstream). */
onSubmit: (text: string) => void;
onStop: () => void;
@@ -56,11 +72,17 @@ export function ChatComposer({
const [slashIndex, setSlashIndex] = useState(0);
const textareaRef = useRef<HTMLTextAreaElement>(null);
- const defaultModelLabel =
- modelOptions.find((option) => option.is_default)?.label ?? "Default";
- const selectedModelLabel =
- modelOptions.find((option) => option.value === model)?.label ??
- defaultModelLabel;
+ const defaultModel = modelOptions.find((option) => option.is_default);
+ const selectedModel =
+ modelOptions.find((option) => option.value === model) ?? defaultModel;
+ const selectedModelLabel = selectedModel?.label ?? "Default";
+ const effortOptions = selectedModel?.reasoning_efforts ?? [];
+ const defaultEffort =
+ selectedModel?.default_reasoning_effort ?? effortOptions[0]?.value;
+ const selectedEffort =
+ effortOptions.find((option) => option.value === reasoningEffort) ??
+ effortOptions.find((option) => option.value === defaultEffort) ??
+ effortOptions[0];
// Slash command autocomplete: open while input starts with "/" and the
// user is still composing the command name (no space yet). After they
@@ -179,25 +201,52 @@ export function ChatComposer({
<DropdownMenuTrigger asChild>
<button
type="button"
- aria-label="Model"
+ aria-label="Model and effort"
disabled={disabled || sendingChat}
className="inline-flex max-w-44 items-center gap-1 rounded-md px-2 py-1 text-xs text-muted-foreground transition-colors hover:text-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50"
>
- <span className="truncate">{selectedModelLabel}</span>
+ <span className="truncate">
+ {selectedModelLabel}
+ {selectedEffort ? ` · ${selectedEffort.label}` : ""}
+ </span>
<ChevronDown className="size-3 shrink-0" aria-hidden />
</button>
</DropdownMenuTrigger>
<DropdownMenuContent align="end" side="top">
+ <DropdownMenuLabel>Model</DropdownMenuLabel>
<DropdownMenuRadioGroup value={model} onValueChange={onPickModel}>
- <DropdownMenuRadioItem value="">
- {defaultModelLabel} (default)
- </DropdownMenuRadioItem>
+ {!defaultModel && (
+ <DropdownMenuRadioItem value="">Default</DropdownMenuRadioItem>
+ )}
{modelOptions.map((m) => (
- <DropdownMenuRadioItem key={m.value} value={m.value}>
+ <DropdownMenuRadioItem
+ key={m.value}
+ value={m.is_default ? "" : m.value}
+ >
{m.label}
</DropdownMenuRadioItem>
))}
</DropdownMenuRadioGroup>
+ {effortOptions.length > 0 && (
+ <>
+ <DropdownMenuSeparator />
+ <DropdownMenuLabel>Reasoning effort</DropdownMenuLabel>
+ <DropdownMenuRadioGroup
+ value={reasoningEffort}
+ onValueChange={onPickReasoningEffort}
+ >
+ {effortOptions.map((option) => (
+ <DropdownMenuRadioItem
+ key={option.value}
+ value={option.value === defaultEffort ? "" : option.value}
+ title={option.description}
+ >
+ {option.label}
+ </DropdownMenuRadioItem>
+ ))}
+ </DropdownMenuRadioGroup>
+ </>
+ )}
</DropdownMenuContent>
</DropdownMenu>
)}
diff --git a/notfair/src/components/chat/use-chat-stream.test.tsx b/notfair/src/components/chat/use-chat-stream.test.tsx
index 97935137..e5dd0a76 100644
--- a/notfair/src/components/chat/use-chat-stream.test.tsx
+++ b/notfair/src/components/chat/use-chat-stream.test.tsx
@@ -12,6 +12,7 @@ const base = {
initialEvents: [] as TranscriptEvent[],
initialCursor: 0,
model: "",
+ reasoningEffort: "",
};
class FakeEventSource {
@@ -172,7 +173,9 @@ it("streams text, tools, lifecycle, error, meta, and perf events", async () => {
if (url === "/api/chat") return Promise.resolve(streamResponse([sse], blocked) as never);
return Promise.resolve(pollResponse() as never);
});
- const { result } = renderHook(() => useChatStream({ ...base, model: "gpt-test" }));
+ const { result } = renderHook(() =>
+ useChatStream({ ...base, model: "gpt-test", reasoningEffort: "xhigh" }),
+ );
let sendPromise!: ReturnType<typeof result.current.send>;
act(() => { sendPromise = result.current.send("hello"); });
await waitFor(() => expect(result.current.pendingAssistant).toBe("Hello world"));
@@ -184,6 +187,7 @@ it("streams text, tools, lifecycle, error, meta, and perf events", async () => {
expect(JSON.parse(String(vi.mocked(fetch).mock.calls.find(([u]) => u === "/api/chat")?.[1]?.body))).toMatchObject({
message: "hello",
model: "gpt-test",
+ reasoning_effort: "xhigh",
});
finish();
await act(async () => {
diff --git a/notfair/src/components/chat/use-chat-stream.ts b/notfair/src/components/chat/use-chat-stream.ts
index 6ac2a2a1..f552c2b2 100644
--- a/notfair/src/components/chat/use-chat-stream.ts
+++ b/notfair/src/components/chat/use-chat-stream.ts
@@ -29,6 +29,7 @@ export function useChatStream({
initialEvents,
initialCursor,
model,
+ reasoningEffort,
}: {
projectSlug: string;
agentSlug: string;
@@ -37,6 +38,8 @@ export function useChatStream({
initialCursor: number;
/** Composer model override value ("" = harness default). */
model: string;
+ /** Composer effort override value ("" = harness default). */
+ reasoningEffort: string;
}) {
const [events, setEvents] = useState<TranscriptEvent[]>(initialEvents);
const [cursor, setCursor] = useState(initialCursor);
@@ -238,6 +241,7 @@ export function useChatStream({
project: projectSlug,
thread: threadId,
...(model ? { model } : {}),
+ ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
}),
signal: ctrl.signal,
});
@@ -318,7 +322,7 @@ export function useChatStream({
}
return { error: null } as const;
},
- [agentSlug, model, pollOnce, projectSlug, sendingChat, threadId],
+ [agentSlug, model, pollOnce, projectSlug, reasoningEffort, sendingChat, threadId],
);
/** Local-view reset for the /clear slash command. */
diff --git a/notfair/src/components/live-transcript.tsx b/notfair/src/components/live-transcript.tsx
index 758d63ba..53089c46 100644
--- a/notfair/src/components/live-transcript.tsx
+++ b/notfair/src/components/live-transcript.tsx
@@ -89,21 +89,48 @@ export function LiveTranscript({
// per project+agent in localStorage; loaded after mount so SSR and the
// first client render agree (no hydration mismatch).
const modelStorageKey = `NotFair:model:${projectSlug}:${agentSlug}`;
+ const effortStorageKey = `NotFair:effort:${projectSlug}:${agentSlug}`;
const [model, setModel] = useState("");
+ const [reasoningEffort, setReasoningEffort] = useState("");
useEffect(() => {
const stored = window.localStorage.getItem(modelStorageKey);
- if (stored && modelOptions.some((m) => m.value === stored)) {
- setModel(stored);
+ const storedOption = modelOptions.find((m) => m.value === stored);
+ if (storedOption && !storedOption.is_default) {
+ setModel(storedOption.value);
+ } else if (storedOption?.is_default) {
+ window.localStorage.removeItem(modelStorageKey);
}
// modelOptions is a fresh array per render from the server page —
// key its identity by content to avoid effect churn.
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [modelStorageKey, JSON.stringify(modelOptions)]);
+ const defaultModel = modelOptions.find((option) => option.is_default);
+ const selectedModel =
+ modelOptions.find((option) => option.value === model) ?? defaultModel;
+ useEffect(() => {
+ const stored = window.localStorage.getItem(effortStorageKey);
+ const supported = selectedModel?.reasoning_efforts ?? [];
+ if (
+ stored &&
+ stored !== selectedModel?.default_reasoning_effort &&
+ supported.some((option) => option.value === stored)
+ ) {
+ setReasoningEffort(stored);
+ } else {
+ setReasoningEffort("");
+ if (stored) window.localStorage.removeItem(effortStorageKey);
+ }
+ }, [effortStorageKey, selectedModel]);
function onPickModel(value: string) {
setModel(value);
if (value) window.localStorage.setItem(modelStorageKey, value);
else window.localStorage.removeItem(modelStorageKey);
}
+ function onPickReasoningEffort(value: string) {
+ setReasoningEffort(value);
+ if (value) window.localStorage.setItem(effortStorageKey, value);
+ else window.localStorage.removeItem(effortStorageKey);
+ }
const defaultModelLabel =
modelOptions.find((option) => option.is_default)?.label ?? "Default";
const selectedModelLabel =
@@ -117,6 +144,7 @@ export function LiveTranscript({
initialEvents,
initialCursor,
model,
+ reasoningEffort,
});
const {
events,
@@ -151,7 +179,7 @@ export function LiveTranscript({
case "set-model": {
const wanted = action.value.toLowerCase();
const names = [
- `${defaultModelLabel} (default)`,
+ ...(defaultModel ? [] : ["Default"]),
...modelOptions.map((m) => m.label),
].join(", ");
if (!wanted) {
@@ -295,7 +323,9 @@ export function LiveTranscript({
}
modelOptions={modelOptions}
model={model}
+ reasoningEffort={reasoningEffort}
onPickModel={onPickModel}
+ onPickReasoningEffort={onPickReasoningEffort}
onSubmit={(text) => void onSubmit(text)}
onStop={stream.stopTurn}
/>
diff --git a/notfair/src/server/adapters/codex-local/execute.test.ts b/notfair/src/server/adapters/codex-local/execute.test.ts
index c5561b00..a7aaa316 100644
--- a/notfair/src/server/adapters/codex-local/execute.test.ts
+++ b/notfair/src/server/adapters/codex-local/execute.test.ts
@@ -133,6 +133,17 @@ describe("executeCodexLocal — argv and env wiring", () => {
expect(args.slice(-3)).toEqual(["resume", uuid, "-"]);
});
+ it("passes a whitelisted reasoning effort as a Codex config override", async () => {
+ scriptSpawn({ stdout: completedTurn });
+ await collect(ctx({ reasoningEffort: "xhigh" }));
+
+ const args = mocks.spawn.mock.calls[0]![1] as string[];
+ expect(args.slice(args.indexOf("-c"), args.indexOf("-c") + 2)).toEqual([
+ "-c",
+ 'model_reasoning_effort="xhigh"',
+ ]);
+ });
+
it("does not resume with a non-codex session id", async () => {
scriptSpawn({ stdout: completedTurn });
await collect(ctx({ harnessSessionId: "sess-not-uuid" }));
diff --git a/notfair/src/server/adapters/codex-local/execute.ts b/notfair/src/server/adapters/codex-local/execute.ts
index 27e266be..87b707cf 100644
--- a/notfair/src/server/adapters/codex-local/execute.ts
+++ b/notfair/src/server/adapters/codex-local/execute.ts
@@ -44,6 +44,12 @@ export async function* executeCodexLocal(
if (ctx.model) {
args.push("-m", ctx.model);
}
+ if (ctx.reasoningEffort) {
+ args.push(
+ "-c",
+ `model_reasoning_effort=${JSON.stringify(ctx.reasoningEffort)}`,
+ );
+ }
// Resume only when we have a real codex thread id from a prior turn.
// NotFair's session UUID is not a codex thread id — passing it would
diff --git a/notfair/src/server/adapters/codex-local/models.test.ts b/notfair/src/server/adapters/codex-local/models.test.ts
index 977d87aa..1df93320 100644
--- a/notfair/src/server/adapters/codex-local/models.test.ts
+++ b/notfair/src/server/adapters/codex-local/models.test.ts
@@ -34,6 +34,35 @@ describe("listCodexModels", () => {
});
});
+ it("carries provider reasoning levels and marks the configured effort dynamically", async () => {
+ const files = await fixture(
+ 'model = "gpt-5.6-sol"\nmodel_reasoning_effort = "xhigh"\n',
+ [
+ {
+ slug: "gpt-5.6-sol",
+ display_name: "GPT-5.6-Sol",
+ priority: 1,
+ default_reasoning_level: "low",
+ supported_reasoning_levels: [
+ { effort: "low", description: "Faster" },
+ { effort: "xhigh", description: "Deeper" },
+ ],
+ },
+ ],
+ );
+
+ const models = await listCodexModels(files.cacheFile, files.configFile);
+
+ expect(models[0]).toMatchObject({
+ value: "gpt-5.6-sol",
+ default_reasoning_effort: "xhigh",
+ reasoning_efforts: [
+ { value: "low", label: "Low", description: "Faster" },
+ { value: "xhigh", label: "Extra high", description: "Deeper" },
+ ],
+ });
+ });
+
it("keeps a configured model visible when the provider cache is stale", async () => {
const files = await fixture('model = "gpt-custom"\n', [
{ slug: "gpt-5.4", display_name: "GPT-5.4", priority: 1 },
diff --git a/notfair/src/server/adapters/codex-local/models.ts b/notfair/src/server/adapters/codex-local/models.ts
index 995fc44e..0c5045d8 100644
--- a/notfair/src/server/adapters/codex-local/models.ts
+++ b/notfair/src/server/adapters/codex-local/models.ts
@@ -28,40 +28,101 @@ type CachedModel = {
visibility?: unknown;
priority?: unknown;
context_window?: unknown;
+ default_reasoning_level?: unknown;
+ supported_reasoning_levels?: unknown;
};
+type CachedReasoningLevel = {
+ effort?: unknown;
+ description?: unknown;
+};
+
+function isCachedReasoningLevel(
+ level: unknown,
+): level is CachedReasoningLevel & { effort: string } {
+ if (typeof level !== "object" || level === null) return false;
+ const effort = (level as CachedReasoningLevel).effort;
+ return typeof effort === "string" && effort.length > 0;
+}
+
const FALLBACK: HarnessModelOption[] = [
{ value: "gpt-5.5", label: "GPT-5.5" },
{ value: "gpt-5.4", label: "GPT-5.4" },
];
-async function readConfiguredModel(configFile: string): Promise<string | null> {
+async function readConfiguredDefaults(configFile: string): Promise<{
+ model: string | null;
+ reasoningEffort: string | null;
+}> {
try {
const raw = await readFile(configFile, "utf8");
// NotFair invokes Codex without a profile, so only the root-level `model`
// applies. Stop at the first TOML table to avoid mistaking a nested key
// for the CLI's effective default.
+ let model: string | null = null;
+ let reasoningEffort: string | null = null;
for (const line of raw.split(/\r?\n/)) {
const trimmed = line.trim();
if (trimmed.startsWith("[")) break;
- const match = /^model\s*=\s*("(?:\\.|[^"\\])*"|'[^']*'|[^\s#]+)\s*(?:#.*)?$/.exec(
- trimmed,
- );
+ const match =
+ /^(model|model_reasoning_effort)\s*=\s*("(?:\\.|[^"\\])*"|'[^']*'|[^\s#]+)\s*(?:#.*)?$/.exec(
+ trimmed,
+ );
if (!match) continue;
- const value = match[1];
+ const value = match[2];
+ let parsed: string;
if (value.startsWith('"')) {
try {
- return JSON.parse(value) as string;
+ parsed = JSON.parse(value) as string;
} catch {
- return null;
+ continue;
}
+ } else {
+ parsed = value.startsWith("'") ? value.slice(1, -1) : value;
}
- return value.startsWith("'") ? value.slice(1, -1) : value;
+ if (match[1] === "model") model = parsed;
+ else reasoningEffort = parsed;
}
+ return { model, reasoningEffort };
} catch {
// Missing or unreadable config means Codex uses its provider default.
}
- return null;
+ return { model: null, reasoningEffort: null };
+}
+
+function effortLabel(value: string): string {
+ const expanded = /^x[a-z]/.test(value) ? `extra ${value.slice(1)}` : value;
+ const spaced = expanded.replace(/[-_]+/g, " ");
+ return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+
+function reasoningMetadata(
+ model: CachedModel,
+ configuredEffort: string | null,
+): Pick<HarnessModelOption, "reasoning_efforts" | "default_reasoning_effort"> {
+ if (!Array.isArray(model.supported_reasoning_levels)) return {};
+ const efforts = model.supported_reasoning_levels
+ .filter(isCachedReasoningLevel)
+ .map((level) => ({
+ value: level.effort,
+ label: effortLabel(level.effort),
+ ...(typeof level.description === "string" && level.description
+ ? { description: level.description }
+ : {}),
+ }));
+ if (efforts.length === 0) return {};
+ const providerDefault =
+ typeof model.default_reasoning_level === "string"
+ ? model.default_reasoning_level
+ : null;
+ const defaultEffort =
+ [configuredEffort, providerDefault, efforts[0]?.value].find(
+ (value) => value && efforts.some((effort) => effort.value === value),
+ ) ?? efforts[0]!.value;
+ return {
+ reasoning_efforts: efforts,
+ default_reasoning_effort: defaultEffort,
+ };
}
function markDefaultModel(
@@ -90,7 +151,7 @@ export async function listCodexModels(
cacheFile: string = join(codexConfigDir(), "models_cache.json"),
configFile: string = join(codexConfigDir(), "config.toml"),
): Promise<HarnessModelOption[]> {
- const configuredModel = await readConfiguredModel(configFile);
+ const configured = await readConfiguredDefaults(configFile);
try {
const raw = await readFile(cacheFile, "utf8");
const parsed = JSON.parse(raw) as { models?: CachedModel[] };
@@ -112,9 +173,10 @@ export async function listCodexModels(
...(typeof m.context_window === "number" && m.context_window > 0
? { context_window: m.context_window }
: {}),
+ ...reasoningMetadata(m, configured.reasoningEffort),
}));
- return markDefaultModel(models.length > 0 ? models : FALLBACK, configuredModel);
+ return markDefaultModel(models.length > 0 ? models : FALLBACK, configured.model);
} catch {
- return markDefaultModel(FALLBACK, configuredModel);
+ return markDefaultModel(FALLBACK, configured.model);
}
}
diff --git a/notfair/src/server/adapters/types.ts b/notfair/src/server/adapters/types.ts
index ba48c003..52d32b04 100644
--- a/notfair/src/server/adapters/types.ts
+++ b/notfair/src/server/adapters/types.ts
@@ -90,6 +90,12 @@ export interface HarnessExecuteContext {
* they reach the adapter.
*/
model?: string | null;
+ /**
+ * Per-turn reasoning effort override from the composer. Adapters that
+ * expose effort metadata validate it in the chat route before execution.
+ * Absent/null = the CLI's own configured default.
+ */
+ reasoningEffort?: string | null;
/** Optional cancellation. When aborted the adapter kills its subprocess. */
signal?: AbortSignal;
}
@@ -141,6 +147,19 @@ export interface HarnessModelOption {
* publishes it in models_cache.json). Absent when unknown.
*/
context_window?: number;
+ /** Reasoning efforts this model supports, sourced from the provider. */
+ reasoning_efforts?: HarnessReasoningEffortOption[];
+ /** Effort used when NotFair omits a per-turn override. */
+ default_reasoning_effort?: string;
+}
+
+export interface HarnessReasoningEffortOption {
+ /** Identifier passed to the harness's effort configuration. */
+ value: string;
+ /** Human label for the dropdown. */
+ label: string;
+ /** Provider-supplied explanation of the speed/depth tradeoff. */
+ description?: string;
}
export interface HarnessAdapter {