fix: default low thinking for reasoning models

src/auto-reply/reply.directive.test.ts

@@ -700,4 +700,48 @@ describe("directive parsing", () => {
       expect(call?.model).toBe("gpt-4.1-mini");
     });
   });
+
+  it("defaults thinking to low for reasoning-capable models", async () => {
+    await withTempHome(async (home) => {
+      const storePath = path.join(home, "sessions.json");
+      vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
+        payloads: [{ text: "done" }],
+        meta: {
+          durationMs: 5,
+          agentMeta: { sessionId: "s", provider: "p", model: "m" },
+        },
+      });
+      vi.mocked(loadModelCatalog).mockResolvedValueOnce([
+        {
+          id: "claude-opus-4-5",
+          name: "Opus 4.5",
+          provider: "anthropic",
+          reasoning: true,
+        },
+      ]);
+
+      await getReplyFromConfig(
+        {
+          Body: "hello",
+          From: "+1004",
+          To: "+2000",
+        },
+        {},
+        {
+          agent: {
+            model: "anthropic/claude-opus-4-5",
+            workspace: path.join(home, "clawd"),
+          },
+          whatsapp: {
+            allowFrom: ["*"],
+          },
+          session: { store: storePath },
+        },
+      );
+
+      expect(runEmbeddedPiAgent).toHaveBeenCalledOnce();
+      const call = vi.mocked(runEmbeddedPiAgent).mock.calls[0]?.[0];
+      expect(call?.thinkLevel).toBe("low");
+    });
+  });
 });

src/auto-reply/reply.ts

@@ -13,6 +13,7 @@ import {
   modelKey,
   resolveConfiguredModelRef,
   resolveModelRefFromString,
+  resolveThinkingDefault,
 } from "../agents/model-selection.js";
 import {
   abortEmbeddedPiRun,
@@ -1094,13 +1095,14 @@ export async function getReplyFromConfig(
     hasModelDirective || hasAllowlist || hasStoredOverride;
   let allowedModelKeys = new Set<string>();
   let allowedModelCatalog: Awaited<ReturnType<typeof loadModelCatalog>> = [];
+  let modelCatalog: Awaited<ReturnType<typeof loadModelCatalog>> | null = null;
   let resetModelOverride = false;
 
   if (needsModelCatalog) {
-    const catalog = await loadModelCatalog({ config: cfg });
+    modelCatalog = await loadModelCatalog({ config: cfg });
     const allowed = buildAllowedModelSet({
       cfg,
-      catalog,
+      catalog: modelCatalog,
       defaultProvider,
     });
     allowedModelCatalog = allowed.allowedCatalog;
@@ -1134,6 +1136,22 @@ export async function getReplyFromConfig(
       model = storedModelOverride;
     }
   }
+  let defaultThinkingLevel: ThinkLevel | undefined;
+  const resolveDefaultThinkingLevel = async () => {
+    if (defaultThinkingLevel) return defaultThinkingLevel;
+    let catalogForThinking = modelCatalog ?? allowedModelCatalog;
+    if (!catalogForThinking || catalogForThinking.length === 0) {
+      modelCatalog = await loadModelCatalog({ config: cfg });
+      catalogForThinking = modelCatalog;
+    }
+    defaultThinkingLevel = resolveThinkingDefault({
+      cfg,
+      provider,
+      model,
+      catalog: catalogForThinking,
+    });
+    return defaultThinkingLevel;
+  };
   contextTokens =
     agentCfg?.contextTokens ??
     lookupContextTokens(model) ??
@@ -1589,7 +1607,8 @@ export async function getReplyFromConfig(
       sessionScope,
       storePath,
       groupActivation,
-      resolvedThink: resolvedThinkLevel,
+      resolvedThink:
+        resolvedThinkLevel ?? (await resolveDefaultThinkingLevel()),
       resolvedVerbose: resolvedVerboseLevel,
       webLinked,
       webAuthAgeMs,
@@ -1820,6 +1839,9 @@ export async function getReplyFromConfig(
       commandBody = parts.slice(1).join(" ").trim();
     }
   }
+  if (!resolvedThinkLevel) {
+    resolvedThinkLevel = await resolveDefaultThinkingLevel();
+  }
 
   const sessionIdFinal = sessionId ?? crypto.randomUUID();
   const sessionFile = resolveSessionTranscriptPath(sessionIdFinal);