clamp legacy loop efforts to auto on hydrate

Author: charlesvien

packages/ui/src/features/loops/components/LoopModelFields.tsx

@@ -88,22 +88,17 @@ export function LoopModelFields({
     ];
   }, [catalog, model]);
 
-  // The current effort stays selectable even when the effective model no longer
-  // supports it (a loop saved under an older default), same as the model list.
+  // An unsupported saved effort can't reach this select: `normalizeLoopFormValues`
+  // clamps it to auto when the form hydrates.
   const reasoningEffortOptions = useMemo(() => {
-    const supported = loopSupportedReasoningEfforts(adapter, model);
-    const efforts =
-      reasoningEffort && !supported.includes(reasoningEffort)
-        ? [...supported, reasoningEffort]
-        : supported;
     return [
       { value: AUTO_REASONING_VALUE, label: "Auto" },
-      ...efforts.map((effort) => ({
+      ...loopSupportedReasoningEfforts(adapter, model).map((effort) => ({
         value: effort,
         label: REASONING_EFFORT_LABELS[effort],
       })),
     ];
-  }, [adapter, model, reasoningEffort]);
+  }, [adapter, model]);
 
   const clearUnsupportedEffort = (
     nextAdapter: LoopSchemas.LoopRuntimeAdapterEnum,

packages/ui/src/features/loops/loopFormTypes.test.ts

@@ -163,6 +163,39 @@ describe("normalizeLoopFormValues", () => {
     const values = validFormValues();
     expect(normalizeLoopFormValues(values)).toBe(values);
   });
+
+  it.each([
+    {
+      name: "unpinned claude with an effort the default model lacks",
+      overrides: { model: "", reasoningEffort: "medium" },
+      expected: null,
+    },
+    {
+      name: "unpinned claude with an effort the default model supports",
+      overrides: { model: "", reasoningEffort: "high" },
+      expected: "high",
+    },
+    {
+      name: "pinned model supporting the effort",
+      overrides: { model: "claude-sonnet-5", reasoningEffort: "medium" },
+      expected: "medium",
+    },
+    {
+      name: "unpinned codex with an effort the default model lacks",
+      overrides: {
+        runtimeAdapter: "codex",
+        model: "",
+        reasoningEffort: "max",
+      },
+      expected: null,
+    },
+  ] as const)(
+    "clamps an unsupported effort to auto: $name",
+    ({ overrides, expected }) => {
+      const values = { ...validFormValues(), ...overrides };
+      expect(normalizeLoopFormValues(values).reasoningEffort).toBe(expected);
+    },
+  );
 });
 
 describe("formValuesToLoopWrite", () => {

packages/ui/src/features/loops/loopFormTypes.ts

@@ -1,5 +1,6 @@
 import type { LoopSchemas } from "@posthog/api-client/loops";
 import { systemTimezone } from "@posthog/ui/primitives/timezone";
+import { loopSupportedReasoningEfforts } from "./loopModelDefaults";
 
 /**
  * A trigger row in the create/edit form. `key` is a client-only stable
@@ -131,10 +132,22 @@ export function emptyLoopFormValues(): LoopFormValues {
 export function normalizeLoopFormValues(
   values: LoopFormValues,
 ): LoopFormValues {
-  if (values.contextTarget && values.visibility !== "team") {
-    return { ...values, visibility: "team" };
+  let normalized = values;
+  if (normalized.contextTarget && normalized.visibility !== "team") {
+    normalized = { ...normalized, visibility: "team" };
+  }
+  // A stored effort can predate a fire-time default change; carrying it into
+  // the form would make every save 400. It fires as auto anyway, so show that.
+  if (
+    normalized.reasoningEffort &&
+    !loopSupportedReasoningEfforts(
+      normalized.runtimeAdapter,
+      normalized.model,
+    ).includes(normalized.reasoningEffort)
+  ) {
+    normalized = { ...normalized, reasoningEffort: null };
   }
-  return values;
+  return normalized;
 }
 
 export function loopToFormValues(loop: LoopSchemas.Loop): LoopFormValues {

packages/ui/src/features/loops/loopModelDefaults.test.ts

@@ -27,6 +27,8 @@ describe("loopSupportedReasoningEfforts", () => {
     ["codex", "", ["low", "medium", "high"]],
     ["codex", "gpt-5.5", ["low", "medium", "high", "xhigh"]],
     ["codex", "gpt-5.6-sol", ["low", "medium", "high", "xhigh", "max"]],
+    ["codex", "gpt-unknown", ["low", "medium", "high"]],
+    ["claude", "claude-unknown", ["low", "medium", "high", "xhigh", "max"]],
   ] as const)(
     "adapter %s with model %j supports %j",
     (adapter, model, expected) => {

packages/ui/src/features/loops/loopModelDefaults.ts

@@ -29,6 +29,9 @@ const EFFORTS_BY_MODEL: Record<string, LoopSchemas.LoopReasoningEffortEnum[]> =
     "claude-sonnet-4-6": LOW_TO_HIGH,
     "gpt-5": LOW_TO_HIGH,
     "gpt-5.5": ["low", "medium", "high", "xhigh"],
+    "gpt-5.6-sol": ALL_EFFORTS,
+    "gpt-5.6-terra": ALL_EFFORTS,
+    "gpt-5.6-luna": ALL_EFFORTS,
   };
 
 export function loopEffectiveModel(
@@ -42,5 +45,7 @@ export function loopSupportedReasoningEfforts(
   adapter: LoopSchemas.LoopRuntimeAdapterEnum,
   model: string,
 ): LoopSchemas.LoopReasoningEffortEnum[] {
-  return EFFORTS_BY_MODEL[loopEffectiveModel(adapter, model)] ?? ALL_EFFORTS;
+  const efforts = EFFORTS_BY_MODEL[loopEffectiveModel(adapter, model)];
+  if (efforts) return efforts;
+  return adapter === "codex" ? LOW_TO_HIGH : ALL_EFFORTS;
 }