Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
import { RecoilRoot } from 'recoil';
import { Constants, ReasoningEffort } from 'librechat-data-provider';
import { submissionByIndex, clearSubmissions } from '@librechat/chat/react';
import { Provider as JotaiProvider, createStore, getDefaultStore } from 'jotai';
import { act, fireEvent, render, renderHook, screen, waitFor } from '@testing-library/react';
import { getReasoningStateKey, pendingReasoningOverrideFamily } from '@librechat/chat/react';
import type {
SettingDefinition,
TConversation,
TReasoningOverride,
TSubmission,
TReasoningCapabilityMap,
} from 'librechat-data-provider';
import type { ReactNode } from 'react';
import { ReasoningControl, useComposerReasoning } from '../Reasoning';
type MockEndpointConfig = {
type?: string;
customParams?: {
defaultParamsEndpoint?: string;
paramDefinitions?: SettingDefinition[];
};
};
let mockEndpointsConfig: Record<string, MockEndpointConfig> | undefined = {};
let mockCapabilities: TReasoningCapabilityMap | undefined;
let mockCapabilitiesLoading = false;
jest.mock('~/data-provider', () => ({
useGetAgentByIdQuery: () => ({ data: undefined }),
useGetEndpointsQuery: () => ({ data: mockEndpointsConfig }),
useReasoningCapabilitiesQuery: (_endpoint: string, config?: { enabled?: boolean }) => ({
data:
config?.enabled === false || mockCapabilities == null
? undefined
: { capabilities: mockCapabilities, expiresInMs: 3_600_000 },
isInitialLoading: config?.enabled !== false && mockCapabilitiesLoading,
}),
}));
jest.mock('~/Providers', () => ({
useAgentsMapContext: () => ({}),
}));
jest.mock('~/hooks', () => ({
useLocalize: () => (key: string) => key,
}));
beforeEach(() => {
mockEndpointsConfig = {};
mockCapabilities = undefined;
mockCapabilitiesLoading = false;
});
const enumSetting: SettingDefinition = {
key: 'reasoning_effort',
label: 'com_endpoint_reasoning_effort',
labelCode: true,
description: 'com_endpoint_openai_reasoning_effort',
descriptionCode: true,
type: 'enum',
component: 'slider',
default: ReasoningEffort.unset,
options: [
ReasoningEffort.unset,
ReasoningEffort.minimal,
ReasoningEffort.low,
ReasoningEffort.medium,
ReasoningEffort.high,
],
enumMappings: {
[ReasoningEffort.unset]: 'com_ui_auto',
[ReasoningEffort.minimal]: 'com_ui_minimal',
[ReasoningEffort.low]: 'com_ui_low',
[ReasoningEffort.medium]: 'com_ui_medium',
[ReasoningEffort.high]: 'com_ui_high',
},
};
const budgetSetting: SettingDefinition = {
key: 'thinkingBudget',
label: 'com_endpoint_thinking_budget',
labelCode: true,
description: 'com_endpoint_google_thinking_budget',
descriptionCode: true,
type: 'number',
component: 'input',
range: { min: -1, positiveMin: 128, max: 32768, step: 128 },
};
afterEach(() => {
clearSubmissions(getDefaultStore());
});
describe('ReasoningControl', () => {
it('renders a compact, localized disclosure for the next message', async () => {
render(
<ReasoningControl
index={0}
setting={enumSetting}
value={{ key: 'reasoning_effort', value: 'medium' } as TReasoningOverride}
onChange={jest.fn()}
/>,
);
const trigger = screen.getByRole('button', {
name: 'com_ui_composer_thinking com_ui_medium',
});
fireEvent.click(trigger);
expect(
await screen.findByRole('dialog', { name: 'com_endpoint_reasoning_effort' }),
).toBeVisible();
expect(screen.queryByText('com_endpoint_openai_reasoning_effort')).not.toBeInTheDocument();
});
it('stages the next vendor-native enum value from an accessible effort scale', async () => {
const onChange = jest.fn();
render(
<ReasoningControl
index={0}
setting={enumSetting}
value={{ key: 'reasoning_effort', value: 'medium' } as TReasoningOverride}
onChange={onChange}
/>,
);
fireEvent.click(screen.getByRole('button', { name: /com_ui_composer_thinking/ }));
const slider = screen.getByRole('slider', { name: 'com_endpoint_reasoning_effort' });
expect(slider).toHaveAttribute('aria-valuenow', '3');
expect(slider).toHaveAttribute('aria-valuetext', 'com_ui_medium');
slider.focus();
fireEvent.keyDown(slider, { key: 'ArrowRight' });
await waitFor(() =>
expect(onChange).toHaveBeenLastCalledWith({ key: 'reasoning_effort', value: 'high' }),
);
});
it('renders a modal dialog with an explicit close control', () => {
render(
<ReasoningControl
index={0}
setting={enumSetting}
value={{ key: 'reasoning_effort', value: 'medium' } as TReasoningOverride}
onChange={jest.fn()}
/>,
);
fireEvent.click(screen.getByRole('button', { name: /com_ui_composer_thinking/ }));
const dialog = screen.getByRole('dialog', { name: 'com_endpoint_reasoning_effort' });
expect(dialog).toBeVisible();
expect(screen.getByRole('button', { name: 'com_ui_close' })).toBeVisible();
});
it('normalizes numeric thinking budgets onto the same scale with exact input and auto', () => {
const onChange = jest.fn();
render(
<ReasoningControl
index={0}
setting={budgetSetting}
value={{ key: 'thinkingBudget', value: 4096 }}
onChange={onChange}
/>,
);
fireEvent.click(screen.getByRole('button', { name: /com_ui_composer_thinking/ }));
const slider = screen.getByRole('slider', { name: 'com_endpoint_thinking_budget' });
expect(slider).toHaveAttribute('aria-valuemin', '128');
expect(slider).toHaveAttribute('aria-valuemax', '32768');
expect(slider).toHaveAttribute('aria-valuenow', '4096');
slider.focus();
fireEvent.keyDown(slider, { key: 'ArrowRight' });
expect(onChange).toHaveBeenLastCalledWith({ key: 'thinkingBudget', value: 4224 });
const input = screen.getByRole('spinbutton', { name: 'com_endpoint_thinking_budget' });
fireEvent.change(input, { target: { value: '8192' } });
fireEvent.blur(input);
expect(onChange).toHaveBeenLastCalledWith({ key: 'thinkingBudget', value: 8192 });
fireEvent.click(screen.getByRole('button', { name: 'com_ui_auto' }));
expect(onChange).toHaveBeenLastCalledWith({ key: 'thinkingBudget', value: -1 });
});
it('clamps an invalid positive budget to the model-specific floor', () => {
const onChange = jest.fn();
render(
<ReasoningControl
index={0}
setting={budgetSetting}
value={{ key: 'thinkingBudget', value: -1 }}
onChange={onChange}
/>,
);
fireEvent.click(screen.getByRole('button', { name: /com_ui_composer_thinking/ }));
const input = screen.getByRole('spinbutton', { name: 'com_endpoint_thinking_budget' });
fireEvent.change(input, { target: { value: '16' } });
fireEvent.blur(input);
expect(onChange).toHaveBeenLastCalledWith({ key: 'thinkingBudget', value: 128 });
});
it.each([undefined, -1, 4096])('does not stage an unchanged numeric budget (%s)', (value) => {
const onChange = jest.fn();
render(
<ReasoningControl
index={0}
setting={budgetSetting}
value={value == null ? undefined : { key: 'thinkingBudget', value }}
onChange={onChange}
/>,
);
fireEvent.click(screen.getByRole('button', { name: /com_ui_composer_thinking/ }));
const input = screen.getByRole('spinbutton', { name: 'com_endpoint_thinking_budget' });
fireEvent.focus(input);
fireEvent.blur(input);
expect(onChange).not.toHaveBeenCalled();
});
it.each([-1, 0])(
'restores the supported minimum (%s) when the numeric field is cleared',
(min) => {
const onChange = jest.fn();
render(
<ReasoningControl
index={0}
setting={{ ...budgetSetting, range: { ...budgetSetting.range!, min } }}
value={{ key: 'thinkingBudget', value: 4096 }}
onChange={onChange}
/>,
);
fireEvent.click(screen.getByRole('button', { name: /com_ui_composer_thinking/ }));
const input = screen.getByRole('spinbutton', { name: 'com_endpoint_thinking_budget' });
fireEvent.change(input, { target: { value: '' } });
fireEvent.blur(input);
expect(onChange).toHaveBeenLastCalledWith({ key: 'thinkingBudget', value: min });
},
);
});
describe('useComposerReasoning', () => {
it('owns one-shot state in Jotai and clears it when the model changes', async () => {
const reasoningStore = createStore();
const conversation = {
conversationId: 'reasoning-conversation',
endpoint: 'openAI',
model: 'gpt-5',
reasoning_effort: ReasoningEffort.medium,
} as TConversation;
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={reasoningStore}>{children}</JotaiProvider>
</RecoilRoot>
);
const rendered = renderHook(
({
activeConversation,
enabled,
hasAddedConversation,
}: {
activeConversation: TConversation;
enabled: boolean;
hasAddedConversation: boolean;
}) =>
useComposerReasoning({
conversation: activeConversation,
index: 0,
hasAddedConversation,
enabled,
}),
{
initialProps: {
activeConversation: conversation,
enabled: true,
hasAddedConversation: false,
},
wrapper,
},
);
expect(rendered.result.current?.setting.key).toBe('reasoning_effort');
act(() => {
rendered.result.current?.setValue({
key: 'reasoning_effort',
value: ReasoningEffort.high,
});
});
expect(reasoningStore.get(pendingReasoningOverrideFamily('reasoning-conversation'))).toEqual({
key: 'reasoning_effort',
value: ReasoningEffort.high,
});
expect(conversation.reasoning_effort).toBe(ReasoningEffort.medium);
rendered.rerender({
activeConversation: { ...conversation, model: 'gpt-5-mini' },
enabled: true,
hasAddedConversation: false,
});
await waitFor(() =>
expect(
reasoningStore.get(pendingReasoningOverrideFamily('reasoning-conversation')),
).toBeUndefined(),
);
rendered.rerender({
activeConversation: conversation,
enabled: true,
hasAddedConversation: false,
});
await waitFor(() => expect(rendered.result.current).not.toBeNull());
act(() => {
rendered.result.current?.setValue({
key: 'reasoning_effort',
value: ReasoningEffort.high,
});
});
expect(reasoningStore.get(pendingReasoningOverrideFamily('reasoning-conversation'))).toEqual({
key: 'reasoning_effort',
value: ReasoningEffort.high,
});
rendered.rerender({
activeConversation: conversation,
enabled: false,
hasAddedConversation: false,
});
await waitFor(() =>
expect(
reasoningStore.get(pendingReasoningOverrideFamily('reasoning-conversation')),
).toBeUndefined(),
);
rendered.rerender({
activeConversation: conversation,
enabled: true,
hasAddedConversation: false,
});
await waitFor(() => expect(rendered.result.current).not.toBeNull());
act(() => {
rendered.result.current?.setValue({
key: 'reasoning_effort',
value: ReasoningEffort.high,
});
});
rendered.rerender({
activeConversation: conversation,
enabled: true,
hasAddedConversation: true,
});
await waitFor(() =>
expect(
reasoningStore.get(pendingReasoningOverrideFamily('reasoning-conversation')),
).toBeUndefined(),
);
});
it('keeps a staged selection when the user returns from a conversation on another model', async () => {
const reasoningStore = createStore();
const staged = { key: 'reasoning_effort' as const, value: ReasoningEffort.high };
const first = {
conversationId: 'staged-conversation',
endpoint: 'openAI',
model: 'gpt-5',
} as TConversation;
const second = {
conversationId: 'other-conversation',
endpoint: 'openAI',
model: 'gpt-5-mini',
} as TConversation;
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={reasoningStore}>{children}</JotaiProvider>
</RecoilRoot>
);
const rendered = renderHook(
({ activeConversation }: { activeConversation: TConversation }) =>
useComposerReasoning({
conversation: activeConversation,
index: 0,
hasAddedConversation: false,
enabled: true,
}),
{ initialProps: { activeConversation: first }, wrapper },
);
await waitFor(() => expect(rendered.result.current).not.toBeNull());
act(() => {
rendered.result.current?.setValue(staged);
});
rendered.rerender({ activeConversation: second });
await waitFor(() => expect(rendered.result.current?.setting.key).toBe('reasoning_effort'));
rendered.rerender({ activeConversation: first });
await waitFor(() => expect(rendered.result.current).not.toBeNull());
expect(reasoningStore.get(pendingReasoningOverrideFamily('staged-conversation'))).toEqual(
staged,
);
});
it('shows the level the branch last ran at until the user picks another', async () => {
const reasoningStore = createStore();
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={reasoningStore}>{children}</JotaiProvider>
</RecoilRoot>
);
const rendered = renderHook(
({ branchReasoning }: { branchReasoning?: TReasoningOverride }) =>
useComposerReasoning({
conversation: {
conversationId: 'branch-conversation',
endpoint: 'openAI',
model: 'gpt-5',
} as TConversation,
index: 0,
enabled: true,
branchReasoning,
}),
{
initialProps: {
branchReasoning: {
key: 'reasoning_effort',
value: ReasoningEffort.high,
} as TReasoningOverride,
},
wrapper,
},
);
await waitFor(() =>
expect(rendered.result.current?.value).toEqual({
key: 'reasoning_effort',
value: ReasoningEffort.high,
}),
);
act(() => {
rendered.result.current?.setValue({ key: 'reasoning_effort', value: ReasoningEffort.low });
});
expect(rendered.result.current?.value).toEqual({
key: 'reasoning_effort',
value: ReasoningEffort.low,
});
});
it('treats a Parameters reset as choosing the default over the branch level', async () => {
const reasoningStore = createStore();
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={reasoningStore}>{children}</JotaiProvider>
</RecoilRoot>
);
const high = { key: 'reasoning_effort', value: ReasoningEffort.high } as TReasoningOverride;
const base = {
conversationId: 'reset-conversation',
endpoint: 'openAI',
model: 'gpt-5',
} as TConversation;
const rendered = renderHook(
({ conversation }: { conversation: TConversation }) =>
useComposerReasoning({ conversation, index: 0, enabled: true, branchReasoning: high }),
{
initialProps: {
conversation: { ...base, reasoning_effort: ReasoningEffort.medium } as TConversation,
},
wrapper,
},
);
await waitFor(() => expect(rendered.result.current?.value).toEqual(high));
rendered.rerender({ conversation: base });
const reset = {
key: 'reasoning_effort',
value: rendered.result.current?.setting.default,
};
await waitFor(() =>
expect(
reasoningStore.get(
pendingReasoningOverrideFamily(getReasoningStateKey('reset-conversation', 0)),
),
).toEqual(reset),
);
expect(rendered.result.current?.value).toEqual(reset);
});
it('lets a Parameters edit replace the branch level, but not a conversation switch', async () => {
const reasoningStore = createStore();
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={reasoningStore}>{children}</JotaiProvider>
</RecoilRoot>
);
const high = { key: 'reasoning_effort', value: ReasoningEffort.high } as TReasoningOverride;
const rendered = renderHook(
({ conversation }: { conversation: TConversation }) =>
useComposerReasoning({ conversation, index: 0, enabled: true, branchReasoning: high }),
{
initialProps: {
conversation: {
conversationId: 'edited-conversation',
endpoint: 'openAI',
model: 'gpt-5',
} as TConversation,
},
wrapper,
},
);
await waitFor(() => expect(rendered.result.current?.value).toEqual(high));
rendered.rerender({
conversation: {
conversationId: 'other-conversation',
endpoint: 'openAI',
model: 'gpt-5',
reasoning_effort: ReasoningEffort.low,
} as TConversation,
});
expect(rendered.result.current?.value).toEqual(high);
rendered.rerender({
conversation: {
conversationId: 'other-conversation',
endpoint: 'openAI',
model: 'gpt-5',
reasoning_effort: ReasoningEffort.medium,
} as TConversation,
});
await waitFor(() =>
expect(rendered.result.current?.value).toEqual({
key: 'reasoning_effort',
value: ReasoningEffort.medium,
}),
);
expect(
reasoningStore.get(
pendingReasoningOverrideFamily(getReasoningStateKey('other-conversation', 0)),
),
).toEqual({ key: 'reasoning_effort', value: ReasoningEffort.medium });
});
it('does not show an inherited level while thinking is switched off', async () => {
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={createStore()}>{children}</JotaiProvider>
</RecoilRoot>
);
const rendered = renderHook(
() =>
useComposerReasoning({
conversation: {
conversationId: 'thinking-off',
endpoint: 'anthropic',
model: 'claude-sonnet-4-6',
thinking: false,
} as TConversation,
index: 0,
enabled: true,
branchReasoning: { key: 'effort', value: 'high' } as TReasoningOverride,
}),
{ wrapper },
);
await waitFor(() => expect(rendered.result.current?.setting.key).toBe('effort'));
expect(rendered.result.current?.value?.value).not.toBe('high');
});
it('keeps a Parameters effort edit a parameter while thinking is switched off', async () => {
const reasoningStore = createStore();
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={reasoningStore}>{children}</JotaiProvider>
</RecoilRoot>
);
const base = {
conversationId: 'thinking-off-edit',
endpoint: 'anthropic',
model: 'claude-sonnet-4-6',
thinking: false,
} as TConversation;
const rendered = renderHook(
({ conversation }: { conversation: TConversation }) =>
useComposerReasoning({ conversation, index: 0, enabled: true }),
{ initialProps: { conversation: { ...base, effort: 'low' } as TConversation }, wrapper },
);
await waitFor(() => expect(rendered.result.current?.setting.key).toBe('effort'));
rendered.rerender({ conversation: { ...base, effort: 'high' } as TConversation });
await waitFor(() => expect(rendered.result.current?.value?.value).toBe('high'));
expect(
reasoningStore.get(
pendingReasoningOverrideFamily(getReasoningStateKey('thinking-off-edit', 0)),
),
).toBeUndefined();
});
it('withdraws a staged level when thinking is switched off, but keeps one picked after', async () => {
const reasoningStore = createStore();
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={reasoningStore}>{children}</JotaiProvider>
</RecoilRoot>
);
const base = {
conversationId: 'thinking-switch',
endpoint: 'anthropic',
model: 'claude-sonnet-4-6',
} as TConversation;
const key = getReasoningStateKey('thinking-switch', 0);
const high = { key: 'effort', value: 'high' } as TReasoningOverride;
const rendered = renderHook(
({ conversation }: { conversation: TConversation }) =>
useComposerReasoning({ conversation, index: 0, enabled: true }),
{ initialProps: { conversation: { ...base, thinking: true } as TConversation }, wrapper },
);
await waitFor(() => expect(rendered.result.current?.setting.key).toBe('effort'));
act(() => {
rendered.result.current?.setValue(high);
});
rendered.rerender({ conversation: { ...base, thinking: false } as TConversation });
await waitFor(() =>
expect(reasoningStore.get(pendingReasoningOverrideFamily(key))).toBeUndefined(),
);
act(() => {
rendered.result.current?.setValue(high);
});
rendered.rerender({ conversation: { ...base, thinking: false } as TConversation });
expect(reasoningStore.get(pendingReasoningOverrideFamily(key))).toEqual(high);
});
it('does not withdraw a level when moving to a conversation with thinking off', async () => {
const reasoningStore = createStore();
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={reasoningStore}>{children}</JotaiProvider>
</RecoilRoot>
);
const high = { key: 'effort', value: 'high' } as TReasoningOverride;
const otherKey = getReasoningStateKey('thinking-off-other', 0);
reasoningStore.set(pendingReasoningOverrideFamily(otherKey), high);
const model = { endpoint: 'anthropic', model: 'claude-sonnet-4-6' };
const rendered = renderHook(
({ conversation }: { conversation: TConversation }) =>
useComposerReasoning({ conversation, index: 0, enabled: true }),
{
initialProps: {
conversation: {
conversationId: 'thinking-on',
thinking: true,
...model,
} as TConversation,
},
wrapper,
},
);
await waitFor(() => expect(rendered.result.current?.setting.key).toBe('effort'));
rendered.rerender({
conversation: {
conversationId: 'thinking-off-other',
thinking: false,
...model,
} as TConversation,
});
await waitFor(() => expect(rendered.result.current?.value).toEqual(high));
expect(reasoningStore.get(pendingReasoningOverrideFamily(otherKey))).toEqual(high);
});
it('does not show a branch level the current model does not take', async () => {
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={createStore()}>{children}</JotaiProvider>
</RecoilRoot>
);
const rendered = renderHook(
() =>
useComposerReasoning({
conversation: {
conversationId: 'branch-conversation',
endpoint: 'openAI',
model: 'gpt-5',
} as TConversation,
index: 0,
enabled: true,
branchReasoning: { key: 'thinkingBudget', value: 4096 } as TReasoningOverride,
}),
{ wrapper },
);
await waitFor(() => expect(rendered.result.current?.setting.key).toBe('reasoning_effort'));
expect(rendered.result.current?.value?.key).toBe('reasoning_effort');
expect(rendered.result.current?.value?.value).not.toBe(4096);
});
it('resolves the control for an ephemeral agent from its encoded target', async () => {
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={createStore()}>{children}</JotaiProvider>
</RecoilRoot>
);
const rendered = renderHook(
({ agentId }: { agentId: string }) =>
useComposerReasoning({
conversation: {
conversationId: 'ephemeral-agent-conversation',
endpoint: 'agents',
agent_id: agentId,
} as TConversation,
index: 0,
hasAddedConversation: false,
enabled: true,
}),
{ initialProps: { agentId: 'openAI__gpt-5___GPT-5' }, wrapper },
);
await waitFor(() => expect(rendered.result.current?.setting.key).toBe('reasoning_effort'));
rendered.rerender({ agentId: 'agent_not_loaded_yet' });
await waitFor(() => expect(rendered.result.current).toBeNull());
});
it('keeps secondary-pane reasoning selection isolated and clears it on target changes', async () => {
const reasoningStore = createStore();
const conversation = {
conversationId: Constants.NEW_CONVO,
endpoint: 'openAI',
model: 'gpt-5',
reasoning_effort: ReasoningEffort.medium,
} as TConversation;
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={reasoningStore}>{children}</JotaiProvider>
</RecoilRoot>
);
type ReasoningProps = { activeConversation: TConversation };
const primary = renderHook(
({ activeConversation }: ReasoningProps) =>
useComposerReasoning({
conversation: activeConversation,
index: 0,
hasAddedConversation: false,
enabled: true,
}),
{
initialProps: { activeConversation: conversation },
wrapper,
},
);
const secondary = renderHook(
({ activeConversation }: ReasoningProps) =>
useComposerReasoning({
conversation: activeConversation,
index: 1,
hasAddedConversation: false,
enabled: true,
}),
{
initialProps: { activeConversation: conversation },
wrapper,
},
);
const primaryKey = getReasoningStateKey(Constants.NEW_CONVO, 0);
const secondaryKey = getReasoningStateKey(Constants.NEW_CONVO, 1);
expect(primary.result.current).not.toBeNull();
expect(secondary.result.current).not.toBeNull();
act(() => {
primary.result.current?.setValue({
key: 'reasoning_effort',
value: ReasoningEffort.high,
});
secondary.result.current?.setValue({
key: 'reasoning_effort',
value: ReasoningEffort.low,
});
});
expect(reasoningStore.get(pendingReasoningOverrideFamily(primaryKey))).toEqual({
key: 'reasoning_effort',
value: ReasoningEffort.high,
});
expect(reasoningStore.get(pendingReasoningOverrideFamily(secondaryKey))).toEqual({
key: 'reasoning_effort',
value: ReasoningEffort.low,
});
secondary.rerender({
activeConversation: { ...conversation, model: 'gpt-5-mini' },
});
await waitFor(() =>
expect(reasoningStore.get(pendingReasoningOverrideFamily(secondaryKey))).toBeUndefined(),
);
expect(reasoningStore.get(pendingReasoningOverrideFamily(primaryKey))).toEqual({
key: 'reasoning_effort',
value: ReasoningEffort.high,
});
});
/* The window between the first submit and the `created`/`sync` event: the
selection for the next turn is written under the placeholder key, and the
durable id arrives afterwards. */
it('carries a selection made before the id resolves onto the saved conversation', async () => {
const reasoningStore = createStore();
const conversation = {
conversationId: Constants.NEW_CONVO,
endpoint: 'openAI',
model: 'gpt-5',
reasoning_effort: ReasoningEffort.medium,
} as TConversation;
const submission = {
conversation: { conversationId: Constants.NEW_CONVO },
userMessage: { conversationId: Constants.NEW_CONVO },
} as TSubmission;
reasoningStore.set(submissionByIndex(0), submission);
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={reasoningStore}>{children}</JotaiProvider>
</RecoilRoot>
);
const rendered = renderHook(
({ activeConversation }: { activeConversation: TConversation }) =>
useComposerReasoning({
conversation: activeConversation,
index: 0,
hasAddedConversation: false,
enabled: true,
}),
{ initialProps: { activeConversation: conversation }, wrapper },
);
const placeholderKey = getReasoningStateKey(Constants.NEW_CONVO, 0);
act(() => {
rendered.result.current?.setValue({
key: 'reasoning_effort',
value: ReasoningEffort.high,
});
});
expect(reasoningStore.get(pendingReasoningOverrideFamily(placeholderKey))).toEqual({
key: 'reasoning_effort',
value: ReasoningEffort.high,
});
rendered.rerender({
activeConversation: { ...conversation, conversationId: 'settled-conversation' },
});
await waitFor(() =>
expect(reasoningStore.get(pendingReasoningOverrideFamily('settled-conversation'))).toEqual({
key: 'reasoning_effort',
value: ReasoningEffort.high,
}),
);
expect(rendered.result.current?.value).toEqual({
key: 'reasoning_effort',
value: ReasoningEffort.high,
});
/* Left behind, the placeholder value would leak into the next new chat in
this pane. */
expect(reasoningStore.get(pendingReasoningOverrideFamily(placeholderKey))).toBeUndefined();
});
it('does not carry a new-chat selection into an unrelated conversation', async () => {
const reasoningStore = createStore();
const conversation = {
conversationId: Constants.NEW_CONVO,
endpoint: 'openAI',
model: 'gpt-5',
reasoning_effort: ReasoningEffort.medium,
} as TConversation;
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={reasoningStore}>{children}</JotaiProvider>
</RecoilRoot>
);
const rendered = renderHook(
({ activeConversation }: { activeConversation: TConversation }) =>
useComposerReasoning({
conversation: activeConversation,
index: 0,
hasAddedConversation: false,
enabled: true,
}),
{ initialProps: { activeConversation: conversation }, wrapper },
);
const placeholderKey = getReasoningStateKey(Constants.NEW_CONVO, 0);
act(() => {
rendered.result.current?.setValue({
key: 'reasoning_effort',
value: ReasoningEffort.high,
});
});
rendered.rerender({
activeConversation: { ...conversation, conversationId: 'unrelated-conversation' },
});
await waitFor(() =>
expect(
reasoningStore.get(pendingReasoningOverrideFamily('unrelated-conversation')),
).toBeUndefined(),
);
expect(reasoningStore.get(pendingReasoningOverrideFamily(placeholderKey))).toEqual({
key: 'reasoning_effort',
value: ReasoningEffort.high,
});
});
it('merges custom definitions and clears values removed by a capability change', async () => {
mockEndpointsConfig = {
custom: {
type: 'openAI',
customParams: {
defaultParamsEndpoint: 'openAI',
paramDefinitions: [
{ key: 'reasoning_effort', default: ReasoningEffort.high } as SettingDefinition,
],
},
},
};
const reasoningStore = createStore();
const conversation = {
conversationId: 'custom-reasoning-conversation',
endpoint: 'custom',
model: 'gpt-5',
} as TConversation;
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={reasoningStore}>{children}</JotaiProvider>
</RecoilRoot>
);
const rendered = renderHook(
() =>
useComposerReasoning({
conversation,
index: 0,
hasAddedConversation: false,
enabled: true,
}),
{ wrapper },
);
expect(rendered.result.current?.setting.default).toBe(ReasoningEffort.high);
expect(rendered.result.current?.setting.options).toContain(ReasoningEffort.low);
act(() => {
rendered.result.current?.setValue({
key: 'reasoning_effort',
value: ReasoningEffort.high,
});
});
mockEndpointsConfig = {
custom: {
type: 'openAI',
customParams: {
defaultParamsEndpoint: 'openAI',
paramDefinitions: [
{
key: 'reasoning_effort',
options: [ReasoningEffort.low],
} as SettingDefinition,
],
},
},
};
rendered.rerender();
await waitFor(() =>
expect(
reasoningStore.get(pendingReasoningOverrideFamily('custom-reasoning-conversation')),
).toBeUndefined(),
);
});
it('exposes the declared effort control for the mock custom endpoint', () => {
mockEndpointsConfig = {
'Mock Provider A': {
type: 'custom',
customParams: {
defaultParamsEndpoint: 'anthropic',
paramDefinitions: [{ key: 'effort' } as SettingDefinition],
},
},
};
const reasoningStore = createStore();
/* A named custom endpoint: the label is not an `EModelEndpoint` member, which
is exactly the shape this case is about. */
const conversation = {
conversationId: 'mock-provider-conversation',
endpoint: 'Mock Provider A',
endpointType: 'custom',
model: 'mock-model-a',
} as unknown as TConversation;
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={reasoningStore}>{children}</JotaiProvider>
</RecoilRoot>
);
const rendered = renderHook(
() =>
useComposerReasoning({
conversation,
index: 0,
hasAddedConversation: false,
enabled: true,
}),
{ wrapper },
);
expect(rendered.result.current?.setting).toMatchObject({
key: 'effort',
options: expect.arrayContaining(['low', 'high']),
});
});
it('preserves restored reasoning while custom endpoint capabilities are loading', async () => {
mockEndpointsConfig = undefined;
const reasoningStore = createStore();
const conversation = {
conversationId: 'loading-reasoning-conversation',
endpoint: 'custom',
model: 'gpt-5',
} as TConversation;
reasoningStore.set(pendingReasoningOverrideFamily('loading-reasoning-conversation'), {
key: 'reasoning_effort',
value: ReasoningEffort.high,
});
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={reasoningStore}>{children}</JotaiProvider>
</RecoilRoot>
);
const rendered = renderHook(
() =>
useComposerReasoning({
conversation,
index: 0,
hasAddedConversation: false,
enabled: true,
}),
{ wrapper },
);
expect(rendered.result.current).toBeNull();
expect(
reasoningStore.get(pendingReasoningOverrideFamily('loading-reasoning-conversation')),
).toEqual({ key: 'reasoning_effort', value: ReasoningEffort.high });
mockEndpointsConfig = {
custom: {
type: 'openAI',
customParams: { defaultParamsEndpoint: 'openAI' },
},
};
rendered.rerender();
await waitFor(() =>
expect(rendered.result.current?.value).toEqual({
key: 'reasoning_effort',
value: ReasoningEffort.high,
}),
);
expect(
reasoningStore.get(pendingReasoningOverrideFamily('loading-reasoning-conversation')),
).toEqual({ key: 'reasoning_effort', value: ReasoningEffort.high });
});
it('clears a restored override whose value the current setting no longer offers', async () => {
mockEndpointsConfig = {
custom: {
type: 'openAI',
customParams: { defaultParamsEndpoint: 'openAI' },
},
};
const reasoningStore = createStore();
const conversation = {
conversationId: 'stale-reasoning-conversation',
endpoint: 'custom',
model: 'gpt-5',
} as TConversation;
reasoningStore.set(pendingReasoningOverrideFamily('stale-reasoning-conversation'), {
key: 'reasoning_effort',
value: 'retired-effort' as ReasoningEffort,
});
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={reasoningStore}>{children}</JotaiProvider>
</RecoilRoot>
);
const rendered = renderHook(
() =>
useComposerReasoning({
conversation,
index: 0,
hasAddedConversation: false,
enabled: true,
}),
{ wrapper },
);
await waitFor(() =>
expect(
reasoningStore.get(pendingReasoningOverrideFamily('stale-reasoning-conversation')),
).toBeUndefined(),
);
expect(rendered.result.current?.setting.key).toBe('reasoning_effort');
});
});
describe('useComposerReasoning: OpenRouter per-model efforts', () => {
const model = 'openai/gpt-6.1-sol';
const conversation = {
title: null,
conversationId: 'openrouter-conversation',
endpoint: 'OpenRouter',
endpointType: 'custom',
model,
createdAt: '',
updatedAt: '',
} as unknown as TConversation;
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={createStore()}>{children}</JotaiProvider>
</RecoilRoot>
);
const render = () =>
renderHook(() => useComposerReasoning({ conversation, index: 0, enabled: true }), { wrapper });
beforeEach(() => {
mockEndpointsConfig = {
OpenRouter: {
type: 'custom',
customParams: {
defaultParamsEndpoint: 'openrouter',
reasoningFormat: 'reasoning_effort',
},
} as MockEndpointConfig,
};
});
it('keeps the branch level when the capabilities reload, not mistaking it for an edit', async () => {
const high = { key: 'reasoning_effort', value: ReasoningEffort.high } as TReasoningOverride;
mockCapabilities = { OpenRouter: { [model]: { efforts: ['low', 'high'] } } };
const store = createStore();
const storeWrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={store}>{children}</JotaiProvider>
</RecoilRoot>
);
const configured = { ...conversation, reasoning_effort: ReasoningEffort.low } as TConversation;
const rendered = renderHook(
() =>
useComposerReasoning({
conversation: configured,
index: 0,
enabled: true,
branchReasoning: high,
}),
{ wrapper: storeWrapper },
);
await waitFor(() => expect(rendered.result.current?.value).toEqual(high));
mockCapabilities = undefined;
mockCapabilitiesLoading = true;
rendered.rerender();
expect(rendered.result.current).toBeNull();
mockCapabilities = { OpenRouter: { [model]: { efforts: ['low', 'high'] } } };
mockCapabilitiesLoading = false;
rendered.rerender();
await waitFor(() => expect(rendered.result.current?.value).toEqual(high));
expect(
store.get(pendingReasoningOverrideFamily(getReasoningStateKey('openrouter-conversation', 0))),
).toBeUndefined();
});
it('offers no control while the capabilities are still loading', () => {
mockCapabilitiesLoading = true;
expect(render().result.current).toBeNull();
});
it('keeps an administrator-defined effort control while the capabilities load', () => {
mockCapabilitiesLoading = true;
mockEndpointsConfig = {
OpenRouter: {
type: 'custom',
customParams: {
defaultParamsEndpoint: 'openrouter',
paramDefinitions: [enumSetting],
},
},
};
expect(render().result.current?.setting.key).toBe('reasoning_effort');
});
it('offers no control when the capabilities could not be read', () => {
mockCapabilities = undefined;
mockCapabilitiesLoading = false;
expect(render().result.current).toBeNull();
});
it('offers only the efforts the selected model supports', () => {
mockCapabilities = { OpenRouter: { [model]: { efforts: ['low', 'high'] } } };
expect(render().result.current?.setting.options).toEqual([
ReasoningEffort.unset,
ReasoningEffort.low,
ReasoningEffort.high,
]);
});
it('hides the control for a model the provider lists without reasoning', () => {
mockCapabilities = { OpenRouter: { [model]: { efforts: [] } } };
expect(render().result.current).toBeNull();
});
it('keeps the generic efforts for a model the catalog does not list', () => {
mockCapabilities = { OpenRouter: { 'meta/other': { efforts: ['low'] } } };
expect(render().result.current?.setting.options).toContain(ReasoningEffort.max);
});
});
describe('useComposerReasoning: restored override while OpenRouter capabilities load', () => {
const model = 'openai/gpt-6.1-sol';
const conversation = {
title: null,
conversationId: 'restored-conversation',
endpoint: 'OpenRouter',
endpointType: 'custom',
model,
createdAt: '',
updatedAt: '',
} as unknown as TConversation;
const staged = { key: 'reasoning_effort', value: ReasoningEffort.low } as TReasoningOverride;
const stagedValue = (store: ReturnType<typeof createStore>) =>
store.get(pendingReasoningOverrideFamily('restored-conversation'));
const setup = () => {
const store = createStore();
store.set(pendingReasoningOverrideFamily('restored-conversation'), staged);
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={store}>{children}</JotaiProvider>
</RecoilRoot>
);
const rendered = renderHook(
() => useComposerReasoning({ conversation, index: 0, enabled: true }),
{ wrapper },
);
return { store, rendered };
};
beforeEach(() => {
mockEndpointsConfig = {
OpenRouter: {
type: 'custom',
customParams: {
defaultParamsEndpoint: 'openrouter',
reasoningFormat: 'reasoning_effort',
},
} as MockEndpointConfig,
};
});
it('keeps a staged override while the capabilities are loading', async () => {
mockCapabilitiesLoading = true;
const { store } = setup();
await act(async () => {});
expect(stagedValue(store)).toEqual(staged);
});
it('keeps a staged override while the capabilities request has failed', async () => {
mockCapabilities = undefined;
mockCapabilitiesLoading = false;
const { store } = setup();
await act(async () => {});
expect(stagedValue(store)).toEqual(staged);
});
it('keeps it once the loaded capabilities confirm it', async () => {
mockCapabilities = { OpenRouter: { [model]: { efforts: ['low', 'high'] } } };
const { store } = setup();
await act(async () => {});
expect(stagedValue(store)).toEqual(staged);
});
it('drops a staged override at once when the target changes while the capabilities load', async () => {
mockCapabilitiesLoading = true;
const store = createStore();
store.set(pendingReasoningOverrideFamily('restored-conversation'), staged);
const wrapper = ({ children }: { children: ReactNode }) => (
<RecoilRoot>
<JotaiProvider store={store}>{children}</JotaiProvider>
</RecoilRoot>
);
const rendered = renderHook(
({ activeModel }: { activeModel: string }) =>
useComposerReasoning({
conversation: { ...conversation, model: activeModel } as TConversation,
index: 0,
enabled: true,
}),
{ wrapper, initialProps: { activeModel: model } },
);
await act(async () => {});
expect(stagedValue(store)).toEqual(staged);
rendered.rerender({ activeModel: 'google/gemini-3.5-flash' });
await act(async () => {});
expect(stagedValue(store)).toBeUndefined();
mockCapabilitiesLoading = false;
mockCapabilities = {
OpenRouter: { 'google/gemini-3.5-flash': { efforts: ['low', 'high'] } },
};
rendered.rerender({ activeModel: 'google/gemini-3.5-flash' });
await act(async () => {});
expect(stagedValue(store)).toBeUndefined();
});
it('keeps a supported override across the loading to loaded transition', async () => {
mockCapabilitiesLoading = true;
const { store, rendered } = setup();
await act(async () => {});
expect(stagedValue(store)).toEqual(staged);
mockCapabilitiesLoading = false;
mockCapabilities = { OpenRouter: { [model]: { efforts: ['low', 'high'] } } };
rendered.rerender();
await act(async () => {});
expect(rendered.result.current?.setting.options).toEqual(['', 'low', 'high']);
expect(stagedValue(store)).toEqual(staged);
});
it('keeps a supported override when a refresh changes the other advertised efforts', async () => {
mockCapabilities = { OpenRouter: { [model]: { efforts: ['low', 'high'] } } };
const { store, rendered } = setup();
await act(async () => {});
expect(stagedValue(store)).toEqual(staged);
mockCapabilities = { OpenRouter: { [model]: { efforts: ['low', 'medium', 'high'] } } };
rendered.rerender();
await act(async () => {});
expect(rendered.result.current?.setting.options).toEqual(['', 'low', 'medium', 'high']);
expect(stagedValue(store)).toEqual(staged);
});
it('clears it only after the loaded capabilities prove it unsupported', async () => {
mockCapabilities = { OpenRouter: { [model]: { efforts: ['high'] } } };
const { store } = setup();
await waitFor(() => expect(stagedValue(store)).toBeUndefined());
});
});