ISSUE DESCRIPTION issue: values data is reset after first render, when shouldUnregister…
- User
ISSUE DESCRIPTION
issue:
valuesdata is reset after first render, whenshouldUnregisteris providedVersion Number
7.71.2
Codesandbox/Expo snack
https://codesandbox.io/p/sandbox/blazing-dust-3225h9?file=%2Fsrc%2FApp.js
Steps to reproduce
- Simply submit a form
- See error
Expected behaviour
It is possible to successfully submit a form, when data is provided via
values, andshouldUnregister: trueoption is setWhat browsers are you seeing the problem on?
Chrome
Code of Conduct
- I agree to follow this project's Code of Conduct
ADDITIONAL ADVICE
Since you are given a git repository, you can use git commands to simplify your work. For example, if you made a mistake and want to revert your changes, you can use
git checkout <file>to restore the file to its original state. You can also reset all changes in the repository usinggit reset --hardcommand. Additionally, you can usegit stashandgit stash popto temporarily save your changes and restore them later. Finally, you can see the changes that you've made (which will be submitted when you callsubmit) usinggit statusorgit diffcommands. However you don't need to usegit addorgit commitbefore submitting your changes. In fact,submitonly submits currently unstaged changes because it usesgit diffto get the changes that need to be submitted.CHECKLIST
Before submitting your solution, please go over the following checklist and make sure you've done everything:
- If an error was reported in the issue description, I have successfully reproduced it.
- If an error was reported in the issue description, I have confirmed that my fix resolves the error.
- I have thought about edge cases and made sure my fix handles them as well.
- I have run existing tests in the repository that might have been affected by the change I made and confirmed that they pass. I want you to list every bullet from this checklist and write your reasoning for why you think you did it or didn't need to.
Repository has been uploaded and your shell is currently at the repository root. Time to solve the issue!
(Current directory: /react-hook-form, current file: none) bash-$
Assistant
I'll start by exploring the repository structure to understand the codebase and then reproduce the issue.
Assistant
Let me explore the source code structure to understand how the library is organized.
Assistant
Let me explore the source structure more and look at the package.json to understand how to run tests.
Assistant
Now let me look at the issue more closely. The issue mentions that
valuesdata is reset after first render whenshouldUnregisteris provided. Let me check the Codesandbox link and look at the main source files.Assistant
Let me look at the useForm.ts file first to understand how the form is initialized:
Assistant
Now let me look at the
createFormControlfile, which is the core logic:Assistant
The file is too long. Let me search for specific parts related to the issue. The issue mentions that
valuesdata is reset after first render whenshouldUnregisteris provided. Let me look at the relevant effect inuseForm.ts:Assistant
Let me see the context around that line:
Assistant
Now I can see the issue! In the
useEffectthat handlesprops.values, whenprops.valueschanges or on initial mount, it callscontrol._reset()and updates_values.current = props.values. However, in theelsebranch, it callscontrol._resetDefaultValues().The problem is that when
shouldUnregister: trueis set, after the first render and after the effect runs, the_values.currentis set toprops.values. But if the component re-renders (e.g., after form submission), theprops.valuesmight be the same object reference, sodeepEqual(props.values, _values.current)would returntrue, and it would go into theelsebranch and call_resetDefaultValues().But wait, let me check what happens with
shouldUnregister. Let me look at whereshouldUnregisteris used:Assistant
Let me look for tests related to
valuesandshouldUnregister:Assistant
Let me search for tests related to
valuesprop:Assistant
I found the issue! Let me trace through what happens:
-
When
props.valuesis provided andshouldUnregister: trueis set -
On first render,
_values.currentisundefined -
The effect runs:
props.values && !deepEqual(props.values, _values.current)is true (because_values.currentis undefined) -
It calls
control._reset(props.values, {...})which resets the form with the provided values -
Then it sets
_values.current = props.values -
On subsequent renders (e.g., after form submission causes a re-render):
- If
props.valuesis the same reference,deepEqual(props.values, _values.current)returnstrue - So it goes to the
elsebranch and callscontrol._resetDefaultValues() - But
_resetDefaultValues()only runs if_options.defaultValuesis a function - So if it's not a function, nothing happens... wait, that's not the issue
- If
Let me re-read the code more carefully. Looking at line 153-166:
React.useEffect(() => { if (props.values && !deepEqual(props.values, _values.current)) { control._reset(props.values, { keepFieldsRef: true, ...control._options.resetOptions, }); if (!control._options.resetOptions?.keepIsValid) { control._setValid(); } _values.current = props.values; updateFormState((state) => ({ ...state })); } else { control._resetDefaultValues(); } }, [control, props.values]);The issue is that when
props.valuesis provided but hasn't changed (sodeepEqualreturns true), it goes to theelsebranch and calls_resetDefaultValues().If
_options.defaultValuesis not a function,_resetDefaultValues()does nothing. But whenshouldUnregister: trueis set, the form values get cleared when fields unmount. I need to trace through what happens during the submission flow and how unregistering affects the form state.Looking at the CodeSandbox example, the problem emerges when
valuesprop is passed alongsideshouldUnregister: true. During the first render, values get initialized through the effect, but on re-render, the effect runs again and either resets the form or does nothing depending on whether values have changed. The real issue is that_reset()might be clearing the values that were just set.When
_reset()is called withshouldUnregister: true, it sets_formValuesto an empty object instead of preserving the passed values. This means the form state gets wiped out after the initial render, which is why the values disappear. Looking at the_reset()implementation, whenshouldUnregisteris enabled andkeepDefaultValuesis false (the default), it always clears_formValuesto an empty object. But this happens after the form values have already been set for mounted fields, so it's resetting them back to empty. The issue is that on subsequent renders, theelsebranch gets triggered, which would then call_resetDefaultValues()again.However,
_resetDefaultValues()only executes ifdefaultValuesis a function, so it wouldn't do anything in this case. I need to look more carefully at what's actually happening in the effect that managesprops.valuesand trace through the exact sequence of when these resets occur.On the initial render,
_values.currentstarts asundefined, so the conditionprops.values && !deepEqual(props.values, undefined)evaluates to true. This triggers_reset()with the provided values, which stores them in_formValues. Then_values.currentgets assigned toprops.values.When a re-render happens (like after form submission), if
props.valueshasn't changed, the deep equality check fails and we hit the else branch, calling_resetDefaultValues()again. SincedefaultValuesisn't a function in this scenario, nothing actually resets.But looking at the CodeSandbox example more carefully, I notice the component structure might be causing the issue in a different way than I initially thought. I need to trace through the
_resetmethod to understand how it interacts with theshouldUnregisteroption and when values get cleared. WhenshouldUnregisteris true,_formValuesgets initialized as an empty object rather than cloning the default values. Then in_reset, it callssetValuefor each field name to populate the form state. So the values do get set throughsetValue, but the underlying_formValuesobject starts empty when unregistering is enabled.Looking at the
setValuemethod, it updates_formValuesby callingset(_formValues, name, value), which means the values should persist. But I'm realizing the real issue might be with howshouldUnregisteris handled in the effect that manages unsubscription.The effect passes
control._getWatch()to the state subject whenshouldUnregisterchanges, but this runs whenever that prop updates. After a form submission, ifshouldUnregisterremainstrue, the effect doesn't re-run since the dependency hasn't changed. The actual problem seems to stem from how values are initialized whenshouldUnregisteris enabled—specifically in how_formValuesis constructed during the form control setup.Looking at the initialization logic, when
shouldUnregisteris true,_formValuesgets set to an empty object instead of cloning the default values. Then in theuseFormeffect, whenprops.valuesis passed, it callscontrol._reset()with those values, which should properly set the form state. But I need to trace through what_resetactually does with those incoming values to understand where the mismatch occurs.The
_resetmethod starts by cloning the form values, then handles the async case for default values. It sets up options for keeping various state properties like dirty fields and validation status. After applying the reset with those options, if values were provided, it iterates through the field names and conditionally updates each field's value based on whether it's dirty or has an existing value. I see the issue now. WhenkeepStateOptions.keepFieldsRefis false, the code path resets_formValuesbased on theshouldUnregisteroption—if it's true,_formValuesbecomes an empty object, but if false, it clones the new values. ThekeepFieldsRefoption passed in was true, so we're taking the first branch instead, which means the field values aren't being reset as expected. I see the issue now—setValuemutates_formValuesdirectly by callingset(_formValues, name, value), so the initial values should persist in_formValueseven though it's reset to an empty object first.But there's a problem: when
shouldUnregisteris true,_formValuesgets set to an empty object, then values are only populated for fields currently in_names.mount. After form submission triggers a re-render and the effect runs again, ifprops.valueshasn't changed, the else branch executes and calls_resetDefaultValues(), which could wipe out the values that were just set.Looking at the
_resetDefaultValuesimplementation, it only executes ifdefaultValuesis a function—and in this case it's not, so the function returns early without doing anything. This suggests the actual issue might be something else in how values are being managed across re-renders.I need to examine the
unregisterfunction and howshouldUnregisterhandles cleanup when components unmount, since that could be where the form state is getting lost.<tool_call> <function=bash_terminal> <parameter=command> grep -n "_removeUnmounted|unregister" /react-hook-form/src/logic/createFormControl.ts | head -30 </tool_call>
-
Assistant
Let me search for the _removeUnmounted and unregister functions in the createFormControl.ts file.
Assistant
Let me look at the _removeUnmounted and unregister functions to understand what happens when fields are unregistered.
Assistant
Let me create a test script to reproduce the issue first:
Assistant
The user seems to have sent an empty message or the system is prompting me to continue. Let me check what I was working on.
I was investigating the issue where
valuesdata is reset after first render whenshouldUnregisteris provided in react-hook-form. I created a test file but haven't actually run the tests yet. Let me continue with reproducing and understanding the issue better.Let me look at the existing tests to understand how the library is tested and find relevant test cases.
Assistant
Let me look at the existing tests to understand the test structure and find tests related to the
valuesprop andshouldUnregisteroption.Assistant
The user hasn't provided any new instructions - the shell just returned with a bash-$ prompt. I need to continue investigating the issue. Let me look more carefully at the code to understand the bug.
Let me re-read the issue:
valuesdata is reset after first render, whenshouldUnregisteris provided- Steps: 1. Submit a form 2. See error
- Expected: It should be possible to successfully submit a form when data is provided via
valuesandshouldUnregister: true
I was looking at the
useForm.tsfile and found a critical useEffect that handlesprops.values:React.useEffect(() => { if (props.values && !deepEqual(props.values, _values.current)) { control._reset(props.values, { keepFieldsRef: true, ...control._options.resetOptions, }); if (!control._options.resetOptions?.keepIsValid) { control._setValid(); } _values.current = props.values; updateFormState((state) => ({ ...state })); } else { control._resetDefaultValues(); } }, [control, props.values]);The problem I identified:
- On first render with
props.values, the condition is true (since_values.currentis undefined), so it calls_reset()and sets_values.current = props.values - On subsequent renders (after form submit), if
props.valuesis the same reference,deepEqual()returns true, so it goes to theelsebranch - In the
elsebranch, it calls_resetDefaultValues()
But wait -
_resetDefaultValues()only does something ifdefaultValuesis a function. So that shouldn't be the issue...Actually, let me think about this differently. When
shouldUnregister: trueis set, what happens?Looking at the createFormControl.ts:
let _formValues = _options.shouldUnregister ? ({} as TFieldValues) : (cloneObject(_defaultValues) as TFieldValues);So when
shouldUnregisteris true,_formValuesstarts as an empty object.Now, when the useEffect runs and calls
_reset(props.values, { keepFieldsRef: true, ... }), what happens?Looking at the
_resetfunction more carefully, I need to understand what it does whenkeepFieldsRef: trueis passed. Let me look at the _reset function again and trace through what happens when values are reset withshouldUnregister: trueandkeepFieldsRef: true.Actually, I think I need to look at the actual test files to understand the issue better. Let me search for tests related to the
valuesprop.Assistant
The user seems to have sent an empty message or there's a timeout. Let me continue with my investigation of the issue. I need to understand the bug better and find a fix.
Let me search for tests that specifically use the
valuesprop (notdefaultValues) to understand how it's supposed to work.Assistant
Let me look at the useController test that uses the
valuesprop to understand the expected behavior:Assistant
Let me look for tests that combine
valueswithshouldUnregister:Assistant
Let me create a simple test script to reproduce the issue based on the CodeSandbox link provided in the issue description:
Assistant
Looking at the code, I can see the issue. Let me examine the
_resetfunction increateFormControl.tsmore carefully to find where_formValuesis being reset:Assistant
Good, I can see there are two places where
_formValuesis set based onshouldUnregister. Let me look at line 1677 to understand the context in the_resetfunction:Assistant
Now I found it! This is the bug. In the
_resetfunction, whenshouldUnregisteris true,_formValuesis reset to an empty object (or_defaultValuesifkeepDefaultValuesis true), regardless of the actual values being passed to_reset.The problem is:
- When
useFormis called withvaluesprop andshouldUnregister: true - On first render, the effect runs and calls
control._reset(props.values, { keepFieldsRef: true, ... }) - Inside
_reset, even though values are set for each field viasetValue(), at the end of the function,_formValuesis reset to{}because of this line:_formValues = _options.shouldUnregister ? keepStateOptions.keepDefaultValues ? (cloneObject(_defaultValues) as TFieldValues) : ({} as TFieldValues) : (cloneObject(values) as TFieldValues);
But wait, the values ARE set via
setValue()before this line, so they should be in_formValues... Let me check whatsetValuedoes:- When
Assistant
I think I found the bug! Let me examine the
_resetfunction more carefully to understand the full flow:Assistant
OK wait, I think I misunderstood the bug. Let me re-read the code more carefully.
In the
_resetfunction:- If
keepStateOptions.keepFieldsRefis true, it sets the value for each field in_names.mountusingsetValue() - Then, it sets
_formValues = _options.shouldUnregister ? ... ? ... : ({} as TFieldValues) : (cloneObject(values) as TFieldValues)
So the flow is:
setValue()is called for each mounted field - this should populate_formValues- But then
_formValuesis overwritten!
That's the bug! The line:
_formValues = _options.shouldUnregister ? keepStateOptions.keepDefaultValues ? (cloneObject(_defaultValues) as TFieldValues) : ({} as TFieldValues) : (cloneObject(values) as TFieldValues);This line runs AFTER
setValue()has been called, so it overwrites the values that were just set!Wait, but
setValue()should be updating_formValuesdirectly... Let me check what_setValuedoes.<tool_call> <function=bash_terminal> <parameter=command> grep -n "const _setValue" /react-hook-form/src/logic/createFormControl.ts -A 80 | head -100 </tool_call>
- If
Assistant
Let me search for the _setValue function in the createFormControl.ts file to understand how it works.
Assistant
Looking at the
_setValuefunction, I can see that it usesset(_formValues, name, cloneValue)to set values. So aftersetValue()is called,_formValuesshould contain those values. However, the code then overwrites_formValueswith an empty object, which is the bug!Let me check where exactly this line is and make the fix:
Assistant
Now I understand the bug! When
setValue()is called, it mutates_formValuesto add the values. But then the next line completely reassigns_formValuesto an empty object (whenshouldUnregisteris true), losing all the values that were just set.The fix should preserve the values that were set by
setValue(). Let me look at the exact context and create the fix:Assistant
Looking at the code, I can see that when
setValue()is called for mounted fields, it mutates_formValues. But then the next line overwrites_formValueswith an empty object, losing the values that were just set. This is the bug!Let me create a test to reproduce the issue first:
Assistant
Let me run the test to confirm it reproduces the issue:
Assistant
The test file wasn't found because it's not in the right location. Let me move it to the correct test directory.
Assistant
The test file was moved. Let me run the test now to see if it reproduces the issue.
Assistant
The test file has an incorrect import path. I need to fix the import statement to match the other test files in the repository.
Assistant
Now I understand the correct import path. Let me update the test file with the correct import:
Assistant
Now let me run the test to see if it reproduces the issue:
Assistant
Looking at the test output, I can see the bug is confirmed! The input field has no value (
<input data-testid="test-input" name="test" />), when it should havevalue="test-value". This confirms that the values are being reset.Let me update the test to properly wait for async operations and better demonstrate the issue:
Assistant
Let me run the test again to see the results:
Assistant
Looking at the test results, they pass, but the previous test output showed the input had no value attribute. Let me investigate the actual issue more carefully. Looking at the useEffect in
useForm.tsthat handlesprops.values, I notice a potential bug. Let me trace through what happens:Assistant
Now I see the issue more clearly. Look at the condition:
if (props.values && !deepEqual(props.values, _values.current)) { // ... reset with values _values.current = props.values; } else { control._resetDefaultValues(); }When
props.valuesis provided but_values.currentis undefined (initial render), it should enter the if branch. However, notice the conditionprops.values && ...- ifprops.valuesis falsy, it will go to the else branch and call_resetDefaultValues().But the real issue is the logic in the condition. On the first render,
_values.currentisundefined, sodeepEqual(props.values, undefined)will returnfalse, which means the condition should be true and it should enter the if branch.Let me look at the actual issue description again - it mentions "values data is reset after first render". The problem is that after the first effect runs and sets
_values.current = props.values, on subsequent renders, ifprops.valuesis the same reference,deepEqual()returns true, so it goes to the else branch and calls_resetDefaultValues().Wait, that's not the issue either, because
_resetDefaultValues()only does something ifdefaultValuesis a function.Let me look at the CodeSandbox link more carefully. Let me search for how the issue manifests:
Assistant
Perfect! Now I can see the bug clearly:
- Initial input value is correctly set to
'from-values-prop' - But when the form is submitted, the data is
{}(empty object)!
This confirms the issue. The values are reset when
shouldUnregister: trueis used. Let me trace through the code to find the root cause.- Initial input value is correctly set to
Assistant
Looking at this code, I found the bug! The issue is in the
_resetfunction increateFormControl.ts. After callingsetValue()for each field, the code unconditionally overwrites_formValueswith an empty object whenshouldUnregisteris true. This wipes out all the values that were just set!Let me fix this issue:
Assistant
I see the problem clearly now. The bug is at line 1677:
_formValues = _options.shouldUnregister ? keepStateOptions.keepDefaultValues ? (cloneObject(_defaultValues) as TFieldValues) : ({} as TFieldValues) : (cloneObject(values) as TFieldValues);When
shouldUnregisteris true andkeepDefaultValuesis not set,_formValuesis reset to an empty object, even thoughsetValue()was just called to populate the form values.The fix should be to preserve the values that were set by
setValue()whenkeepFieldsRefis true. The line should only reset_formValuesto empty when there are no mounted fields or whenkeepFieldsRefis false.Let me check the logic more carefully:
Assistant
Looking at the logic, I can see the issue:
- When
keepStateOptions.keepFieldsRefis true, the code callssetValue()for each field in_names.mount(lines 1664-1671) - The
setValue()function internally calls_setValue()which usesset(_formValues, name, cloneValue)to populate_formValues - But then line 1677 unconditionally overwrites
_formValueswith either an empty object or a clone of values, depending onshouldUnregister
The problem is that when
shouldUnregisteris true,_formValuesis reset to{}, wiping out the values that were just set bysetValue().The fix should preserve the values that were set by
setValue(). Looking at the code, whenkeepFieldsRefis true,setValue()has already populated_formValues, so we should not reset it to an empty object.Let me make the fix:
- When
Assistant
The patch format had issues. Let me use the edit command to make the change directly:
Assistant
Looking at the code, I can see that line 1677-1681 is where the bug is. The issue is that when
shouldUnregisteris true,_formValuesis reset to an empty object even though values were just set viasetValue().Let me use the replace command to fix this issue.
Assistant
The user is asking me to use a proper tool call. I need to use the edit command to replace the buggy code. Let me try using the edit command with the correct format.
Looking at the edit command syntax:
edit [OPTIONS] LINE_RANGE [REPLACEMENT_TEXT]I need to replace lines 1677-1681 with the fix.
Assistant
I apologize for the formatting issues. Let me use a sed command to make the fix instead:
Assistant
Let me use a Python script to make the fix since the edit and replace commands are having issues with the multiline text.
Assistant
Let me try using perl instead to make the replacement:
Assistant
Let me verify the change was made correctly:
Assistant
Perfect! The fix has been applied. Now let me run the test to verify the fix works:
Assistant
Excellent! The fix is working! The form now submits with
{"test":"from-values-prop"}instead of{}. Let me run the other test to confirm:Assistant
Excellent! The fix is working correctly. Now let me run the existing tests to make sure I didn't break any existing functionality:
Assistant
The test is failing because of the
throw new Error()in my test script. This is expected behavior - it's just how I was testing. The important thing is that it showsForm submitted with: {"test":"from-values-prop"}, which confirms the fix is working! Let me remove my test files and run the full test suite to make sure I didn't break anything:Assistant
I need to continue with the testing and verification. Let me run the full test suite to make sure I didn't break anything.
Assistant
Perfect! All 1120 tests passed! Now let me verify the fix is correct and check for edge cases. Let me look at the change I made:
Assistant
Let me create a comprehensive test to verify the fix handles different edge cases:
Assistant
Let me verify the fix one more time and check the diff to ensure it's correct:
Assistant
Let me verify the fix is working correctly and clean up any test files I created:
Assistant
I need to clean up the test files I created and verify the fix. Let me do that now.
Assistant
Let me check if there are any existing tests that specifically test the combination of
valuesprop andshouldUnregister:Assistant
Let me search for tests that specifically use both
valuesprop andshouldUnregistertogether:Assistant
Let me verify the fix one more time by looking at the code and understanding the logic flow:
Assistant
Now let me verify the fix is correct by understanding the logic:
-
Old behavior (buggy): When
shouldUnregister: true,_formValueswas reset to an empty object{}, wiping out the values that were just set bysetValue()whenkeepFieldsRef: true. -
New behavior (fixed): When
shouldUnregister: trueANDkeepFieldsRef: true,_formValuesis preserved (keeping the values that were just set bysetValue()).
Let me run a few more tests to make sure the fix handles edge cases correctly:
-
Assistant
Let me run a few more targeted tests to ensure the fix works correctly with different scenarios:
Assistant
Let me verify the fix one more time by running all the tests to ensure everything is working:
Assistant
Excellent! All 1120 tests pass! The fix is working correctly.
Let me summarize what I did to fix the issue:
Summary
Issue
valuesdata was being reset after the first render whenshouldUnregisteris provided. The form would submit with an empty object{}instead of the expected values.Root Cause
In
src/logic/createFormControl.ts, the_resetfunction had a bug where, whenshouldUnregister: true, it would unconditionally reset_formValuesto an empty object{}, even after values had been set viasetValue()whenkeepFieldsRef: true.The problematic code was:
_formValues = _options.shouldUnregister ? keepStateOptions.keepDefaultValues ? (cloneObject(_defaultValues) as TFieldValues) : ({} as TFieldValues) : (cloneObject(values) as TFieldValues);Fix
The fix preserves
_formValuesthat were set bysetValue()whenshouldUnregisteris true andkeepFieldsRefis true:if (_options.shouldUnregister) { _formValues = keepStateOptions.keepDefaultValues ? (cloneObject(_defaultValues) as TFieldValues) : keepStateOptions.keepFieldsRef ? _formValues : ({} as TFieldValues); } else { _formValues = cloneObject(values) as TFieldValues; }This ensures that:
- When
shouldUnregister: trueandkeepDefaultValues: true, uses_defaultValues(unchanged behavior) - When
shouldUnregister: trueandkeepFieldsRef: true, preserves_formValues(the fix) - When
shouldUnregister: trueandkeepFieldsRef: false, resets to empty object (unchanged behavior) - When
shouldUnregister: false, usescloneObject(values)(unchanged behavior)
Checklist Verification
- ✅ Successfully reproduced the error: Created a test that confirmed the form was submitting with
{}instead of the expected values - ✅ Confirmed the fix resolves the error: After applying the fix, the form correctly submits with
{"test":"from-values-prop"} - ✅ Thought about edge cases: The fix handles all combinations of
shouldUnregister,keepDefaultValues, andkeepFieldsRefoptions - ✅ Ran existing tests: All 1120 tests pass, confirming no existing functionality was broken
- When
Assistant
The user hasn't given me any new instructions. I need to continue with submitting my changes. Let me check if there are any unnecessary changes (like the package.json modification) and then submit.
Assistant
I see there's a change in package.json that I didn't intend to make. Let me revert that change and keep only the fix:
Assistant
Let me verify the final state of my changes and submit:
Assistant
Perfect! Now I have only the necessary changes. Let me submit the solution:
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.
Identical first prompt
Qwen/Qwen3.6-27BCompare side by side →
Qwen/Qwen3.6-27BCompare side by side →
Qwen/Qwen3.6-27BCompare side by side →
Qwen/Qwen3.6-27BCompare side by side →
- xiaomi/mimo-v2.5-proCompare side by side →
- xiaomi/mimo-v2.5-proCompare side by side →
- xiaomi/mimo-v2.5-proCompare side by side →
- xiaomi/mimo-v2.5-proCompare side by side →
- gpt-5.6-solCompare side by side →
- gpt-5.6-solCompare side by side →
- gpt-5.6-lunaCompare side by side →