fix(frontend): prefer strong model as assistant composer default (#14058)

* fix(frontend): prefer strong model as assistant default

* chore(agentic): remove orphaned assistant flows

Author: Cristhianzl

src/backend/base/langflow/agentic/flows/LangflowAssistant.json

@@ -156,6 +156,128 @@ describe("ModelSelector", () => {
     });
   });
 
+  describe("out-of-the-box default model (LE-1767)", () => {
+    it("should_auto_select_first_strong_model_when_a_weak_model_comes_first_in_catalog_order", () => {
+      // Arrange — QA repro: weak model first in catalog order, no stored selection
+      mockFilteredProviders = [
+        {
+          provider: "OpenAI",
+          icon: "OpenAI",
+          models: [{ model_name: "gpt-4o-mini" }, { model_name: "gpt-4o" }],
+        },
+      ];
+
+      const onModelChange = jest.fn();
+
+      // Act — fresh user: nothing in localStorage → selectedModel is null
+      render(
+        <ModelSelector selectedModel={null} onModelChange={onModelChange} />,
+      );
+
+      // Assert — the strong model is picked, not allModels[0]
+      expect(onModelChange).toHaveBeenCalledWith(
+        expect.objectContaining({ provider: "OpenAI", name: "gpt-4o" }),
+      );
+      expect(
+        screen.queryByTestId("assistant-model-weak-hint"),
+      ).not.toBeInTheDocument();
+    });
+
+    it("should_auto_select_strong_model_from_later_provider_when_first_provider_only_has_weak_models", () => {
+      // Arrange — first provider offers only a weak SKU; strong model lives in the next provider
+      mockFilteredProviders = [
+        {
+          provider: "OpenAI",
+          icon: "OpenAI",
+          models: [{ model_name: "gpt-4o-mini" }],
+        },
+        {
+          provider: "Anthropic",
+          icon: "Anthropic",
+          models: [{ model_name: "claude-sonnet-4-20250514" }],
+        },
+      ];
+
+      const onModelChange = jest.fn();
+
+      // Act
+      render(
+        <ModelSelector selectedModel={null} onModelChange={onModelChange} />,
+      );
+
+      // Assert
+      expect(onModelChange).toHaveBeenCalledWith(
+        expect.objectContaining({
+          provider: "Anthropic",
+          name: "claude-sonnet-4-20250514",
+        }),
+      );
+    });
+
+    it("should_fall_back_to_first_model_and_show_hint_when_every_enabled_model_is_weak", () => {
+      // Arrange — user enabled only weak SKUs; there is no strong model to prefer
+      mockFilteredProviders = [
+        {
+          provider: "OpenAI",
+          icon: "OpenAI",
+          models: [
+            { model_name: "gpt-4o-mini" },
+            { model_name: "gpt-4.1-nano" },
+          ],
+        },
+      ];
+
+      const onModelChange = jest.fn();
+
+      // Act
+      render(
+        <ModelSelector selectedModel={null} onModelChange={onModelChange} />,
+      );
+
+      // Assert — degrades to today's behavior: first enabled model, hint visible
+      expect(onModelChange).toHaveBeenCalledWith(
+        expect.objectContaining({ provider: "OpenAI", name: "gpt-4o-mini" }),
+      );
+      expect(
+        screen.getByTestId("assistant-model-weak-hint"),
+      ).toBeInTheDocument();
+    });
+
+    it("should_not_override_an_explicit_weak_selection_the_user_made", () => {
+      // Arrange — the user deliberately picked the weak model; the default must not fight them
+      mockFilteredProviders = [
+        {
+          provider: "OpenAI",
+          icon: "OpenAI",
+          models: [{ model_name: "gpt-4o-mini" }, { model_name: "gpt-4o" }],
+        },
+      ];
+
+      const weakModel: AssistantModel = {
+        id: "OpenAI-gpt-4o-mini",
+        name: "gpt-4o-mini",
+        provider: "OpenAI",
+        displayName: "gpt-4o-mini",
+      };
+
+      const onModelChange = jest.fn();
+
+      // Act
+      render(
+        <ModelSelector
+          selectedModel={weakModel}
+          onModelChange={onModelChange}
+        />,
+      );
+
+      // Assert — selection is respected; the advisory hint still shows
+      expect(onModelChange).not.toHaveBeenCalled();
+      expect(
+        screen.getByTestId("assistant-model-weak-hint"),
+      ).toBeInTheDocument();
+    });
+  });
+
   describe("stale model from localStorage", () => {
     it("should_auto_select_first_available_model_when_selected_provider_is_no_longer_available", () => {
       // Arrange — only Anthropic is configured, but selectedModel is a stale OpenAI model from localStorage

src/backend/base/langflow/agentic/flows/SystemMessageGen.json

@@ -55,26 +55,35 @@ export function ModelSelector({
     );
   }, [enabledProviders]);
 
-  // Auto-select first available model if none selected or if the selected model
+  // Catalog order can put a weak SKU first (LE-1767): default to the first
+  // strong model; allModels[0] only when every enabled model is weak.
+  const defaultModel = useMemo(
+    () =>
+      allModels.find((m) => classifyModelStrength(m.name) === "strong") ??
+      allModels[0] ??
+      null,
+    [allModels],
+  );
+
+  // Auto-select the default model if none selected or if the selected model
   // is no longer available (e.g., provider was removed or model was disabled)
   useEffect(() => {
-    if (allModels.length === 0) return;
+    if (!defaultModel) return;
 
     const isSelectedModelValid =
       selectedModel && allModels.some((m) => m.id === selectedModel.id);
 
     if (!isSelectedModelValid) {
-      const defaultModel = allModels[0];
       onModelChange({
         id: defaultModel.id,
         name: defaultModel.name,
         provider: defaultModel.provider,
         displayName: defaultModel.displayName,
       });
     }
-  }, [selectedModel, allModels, onModelChange]);
+  }, [selectedModel, allModels, defaultModel, onModelChange]);
 
-  const currentModel = selectedModel || allModels[0] || null;
+  const currentModel = selectedModel || defaultModel;
 
   // Resolve the provider icon for the currently selected model
   const currentProviderIcon = useMemo(() => {
@@ -95,12 +104,8 @@ export function ModelSelector({
     setIsOpen(false);
   };
 
-  // Discreet UX hint: when the selected model is too small for agent loops
-  // (heuristic in helpers/model-strength.ts), surface an inline italic note
-  // next to the chip. Classification is advisory; the dropdown behaves the
-  // same regardless of result. Re-evaluated on every change of currentModel.
-  // Must stay above the early returns below — Rules of Hooks: hook count
-  // can't change between renders, and isLoading flips false on first fetch.
+  // Advisory hint only (dropdown behaves the same). Must stay above the early
+  // returns below — Rules of Hooks: isLoading flips false after first fetch.
   const modelStrength = useMemo(
     () => classifyModelStrength(currentModel?.name ?? ""),
     [currentModel?.name],
@@ -135,9 +140,8 @@ export function ModelSelector({
   }
 
   return (
-    // gap-3: leaves room for the chip's focus ring (~4px outline + offset)
-    // so the italic warning to the right doesn't visually overlap it after
-    // the user clicks the dropdown and the button keeps keyboard focus.
+    // gap-3 leaves room for the chip's focus ring so the italic warning
+    // doesn't overlap it while the button keeps keyboard focus.
     <div className="flex items-center gap-3">
       <DropdownMenu open={isOpen} onOpenChange={setIsOpen}>
         <DropdownMenuTrigger asChild>