this also could have been if (previewParam.type === "list(string) && param.options.length > 0)
but it feels like checking the form_type is more specific and the only case that needs this logic

An alternative to avoid the boolean ref and the dependency array could be to add refs for the dependencies

const currentParameters = initialParametersRef.current;
const currentRichParams = initialRichParameterValuesRef.current;
const currentSendMessage = sendMessageRef.current;

For something like this, you don't want to sync state via useEffect, because that means the UI completes a full render with the wrong data (including painting the screen), the state sync happens, and then you have to redo the whole render (possibly introducing screen flickering)

This is how I'd do it, and the React Docs recommend it, too:

const [localValue, setLocalValue] = useState(
  value !== undefined ? value : validValue(parameter.value),
);
if (value !== undefined && value !== localValue) {
  setLocalValue(value);
}

Setting state mid-render is valid, as long as you eventually hit a case where you stop calling the state setter. Inside an event handler, the state setter will bail out of re-renders if you dispatch a state value that's equal to the value currently in state. That protection is removed during a render to make sure the user doesn't call a state setter unconditionally

This approach limits the "scope of the redo", because what happens is:

1. Let's say Component A is defined in terms of Component B and Component C
2. Component A starts rendering
3. The state changes mid-render
4. The render for Component A finishes. Any effects and event handlers that were defined inside the component are created as monadic functions, and the JSX object output is returned, which includes component references for Component B and Component C
5. React sees that the state changed, and knows that the result it produced is invalid
6. It throws away the effects, event handlers, and JSX objects. At this point, Component B and Component C have not been allowed to start rendering
7. React redoes the render for Component A
8. The state stays stable this time around
9. React knows that the output is fine this time, so it proceeds to use the JSX object output to render Component B and Component C – for the very first time in this specific render cycle
10. The whole subtree finishes rendering, and then paints the whole updated output to the screen

Though (lol), after writing all that out, I think the better option would be to remove the state entirely, and then pass this to the value prop: value ?? validValue(parameter.value)

How much churn has this component had? I see a bunch of undefined checks for localValue, even though it's guaranteed to always be a string

Is there anything associating this label to the field? Would we want to pass the ID down, as well?

If this is only being used for a truthy check to influence the conditional rendering, can we replace this with an autofill boolean?

I know this wasn't part of the changes, but could we fix this? The second condition will never trigger, because an empty string is inherently falsey

const hasDescription = Boolean(parameter.description);

Nit: I feel like Link is a confusing name without a rename on import, since it sounds like it's a non-icon component

Nit: if we're going to extract this into a separate variable, can we wrap it in Boolean? The current type signature is string | false | undefined

We shouldn't be logging anything from within code that gets run in a render path. If there's an error, could we derive an error value, and then wire things up so that we log that via an effect?

Have we measured whether this actually helps performance? My gut instinct is that initializing an object like this would be pretty cheap, and that adding useMemo would actually make performance worse

I'm going to be honest: an effect like this strikes me as a massive code smell. This might be a case where the React primitives are falling apart, and we do have to do this, but my first instinct is to try remodeling the state in the parent component to make this kind of logic unnecessary

I feel like it might be better if we pair on Monday, so that I can get a sense for what you were going for. At the very least, I feel like there are ways to shrink the dependency array to minimize the ways that it's allowed to re-run:

const initialParams = ???;
useEffect(() => {
  // ???
}, [sendMessage, initialParams]);

Nit: Record<string, string> is fully equivalent here, since we're not relying on recursion over type index signatures