Pass configured effort through to split-plan generation

src/domain/llm/effort.ts

@@ -1,4 +1,4 @@
-export { seedProviderConfig, withModel, withMinEffort, selectEffortForProvider };
+export { seedProviderConfig, withModel, selectEffortForProvider };
 
 import { type Future } from "@/libs/future";
 import {
@@ -7,10 +7,9 @@ import {
   type OpenAIModelEffort,
   type XaiEffort,
   type AnthropicEffort,
-  type GeminiEffort,
-  GEMINI_EFFORTS
+  type GeminiEffort
 } from "@/domain/config/config";
-import { Just, Nothing, type Maybe } from "@/libs/maybe";
+import { Nothing, type Maybe } from "@/libs/maybe";
 import { selectOpenAIEffort, selectAnthropicEffort, selectGeminiEffort, selectXaiEffort } from "@/infra/ui/effort-picker";
 import { absurd } from "@/libs/types";
 
@@ -44,21 +43,6 @@ const withModel = (ai: ProviderConfig, model: string): ProviderConfig => {
   }
 };
 
-const withMinEffort = (config: ProviderConfig): ProviderConfig => {
-  switch (config.provider) {
-    case "openai":
-      return { provider: "openai", model: config.model, auth_method: config.auth_method, effort: Just("low") };
-    case "anthropic":
-      return { provider: "anthropic", model: config.model, auth_method: config.auth_method, effort: Just("low") };
-    case "gemini":
-      return { provider: "gemini", model: config.model, auth_method: config.auth_method, effort: Just(GEMINI_EFFORTS[0]) };
-    case "xai":
-      return { provider: "xai", model: config.model, auth_method: config.auth_method, effort: Just("low") };
-    default:
-      return absurd(config, "ProviderConfig");
-  }
-};
-
 const selectEffortForProvider = (current: ProviderConfig, modelEffort: Maybe<OpenAIModelEffort> = Nothing()): Future<Error, ProviderConfig> => {
   switch (current.provider) {
     case "openai":

src/domain/llm/router.ts

@@ -25,7 +25,6 @@ import { getPrompt, getRefinePrompt, getBranchNamePrompt, getSplitPrompt } from
 import { parseAndValidateBranchSuggestions, type BranchSuggestion } from "@/domain/branch/suggestions";
 import { parseAndValidateSplitPlan, type SplitPlan } from "@/domain/split/plan";
 import { withTransientRetry } from "@/domain/llm/retry";
-import { withMinEffort } from "@/domain/llm/effort";
 import { Maybe, Nothing } from "@/libs/maybe";
 
 type GenerateContentParams = {
@@ -147,7 +146,7 @@ const generateSplitPlan = (
   customTemplate: Maybe<string>
 ): Future<Error, SplitPlanContent> =>
   withTransientRetry(() =>
-    generateContent(withMinEffort(config), { prompt: getSplitPrompt(diff, files, convention, customTemplate) }).chain((gc) =>
+    generateContent(config, { prompt: getSplitPrompt(diff, files, convention, customTemplate) }).chain((gc) =>
       resultToFuture(parseAndValidateSplitPlan(gc.text, files)).map((plan) => ({ plan, metadata: gc.metadata }))
     )
   );

test/domain/llm/router.test.ts

@@ -76,16 +76,16 @@ describe("generateSplitPlan", () => {
     expect(result.metadata.model.provider).toBe("openai");
   });
 
-  it("calls the provider with minimum effort", async () => {
+  it("passes the configured effort through to the provider", async () => {
     const { generateContentWithOpenAI } = await import("@/infra/llm/openai");
     vi.mocked(generateContentWithOpenAI).mockClear();
     const json = JSON.stringify({
       should_split: false,
       commits: [{ message: "feat: a", files: ["a.ts"] }]
     });
-    vi.mocked(generateContentWithOpenAI).mockReturnValue(Future.resolve({ text: json, tokens: Nothing(), effectiveEffort: Just("low") }));
+    vi.mocked(generateContentWithOpenAI).mockReturnValue(Future.resolve({ text: json, tokens: Nothing(), effectiveEffort: Just("high") }));
     const config = { ...mockProvider("openai"), effort: Just("high") } as ProviderConfig;
     await runFuture(generateSplitPlan(config, "diff", ["a.ts"], "conventional", Nothing()));
-    expect(vi.mocked(generateContentWithOpenAI).mock.calls[0]?.[0].effort).toEqual(Just("low"));
+    expect(vi.mocked(generateContentWithOpenAI).mock.calls[0]?.[0].effort).toEqual(Just("high"));
   });
 });