fix: hide adaptive think option for GPT models

extensions/amazon-bedrock/index.test.ts

@@ -107,6 +107,12 @@ describe("amazon-bedrock provider plugin", () => {
         modelId: "amazon.nova-micro-v1:0",
       } as never),
     ).toBeUndefined();
+    expect(
+      provider.supportsAdaptiveThinking?.({
+        provider: "amazon-bedrock",
+        modelId: "us.anthropic.claude-opus-4-6-v1",
+      } as never),
+    ).toBe(true);
   });
 
   it("owns Anthropic-style replay policy for Claude Bedrock models", async () => {

extensions/amazon-bedrock/register.sync.runtime.ts

@@ -191,6 +191,7 @@ export function registerAmazonBedrockPlugin(api: OpenClawPluginApi): void {
       }
       return undefined;
     },
+    supportsAdaptiveThinking: ({ modelId }) => claude46ModelRe.test(modelId.trim()),
     resolveDefaultThinkingLevel: ({ modelId }) =>
       claude46ModelRe.test(modelId.trim()) ? "adaptive" : undefined,
   });

extensions/anthropic/index.test.ts

@@ -218,6 +218,18 @@ describe("anthropic provider replay hooks", () => {
         modelId: "claude-opus-4-6",
       } as never),
     ).toBe(false);
+    expect(
+      provider.supportsAdaptiveThinking?.({
+        provider: "anthropic",
+        modelId: "claude-opus-4-7",
+      } as never),
+    ).toBe(true);
+    expect(
+      provider.supportsAdaptiveThinking?.({
+        provider: "anthropic",
+        modelId: "claude-opus-4-6",
+      } as never),
+    ).toBe(true);
   });
 
   it("resolves claude-cli synthetic oauth auth", async () => {

extensions/anthropic/register.runtime.ts

@@ -278,6 +278,10 @@ function isAnthropicOpus47Model(modelId: string): boolean {
   );
 }
 
+function supportsAnthropicAdaptiveThinking(modelId: string): boolean {
+  return shouldUseAnthropicAdaptiveThinkingDefault(modelId) || isAnthropicOpus47Model(modelId);
+}
+
 function matchesAnthropicModernModel(modelId: string): boolean {
   const lower = normalizeLowercaseStringOrEmpty(modelId);
   return ANTHROPIC_MODERN_MODEL_PREFIXES.some((prefix) => lower.startsWith(prefix));
@@ -490,6 +494,7 @@ export function buildAnthropicProvider(): ProviderPlugin {
     isModernModelRef: ({ modelId }) => matchesAnthropicModernModel(modelId),
     resolveReasoningOutputMode: () => "native",
     supportsXHighThinking: ({ modelId }) => isAnthropicOpus47Model(modelId),
+    supportsAdaptiveThinking: ({ modelId }) => supportsAnthropicAdaptiveThinking(modelId),
     wrapStreamFn: wrapAnthropicProviderStream,
     resolveDefaultThinkingLevel: ({ modelId }) =>
       isAnthropicOpus47Model(modelId)

extensions/discord/src/monitor/native-command.think-autocomplete.test.ts

@@ -34,6 +34,7 @@ const resolveConfiguredBindingRouteMock = vi.hoisted(() =>
   vi.fn<ResolveConfiguredBindingRoute>(() => createUnboundConfiguredRouteResult()),
 );
 const providerThinkingMocks = vi.hoisted(() => ({
+  resolveProviderAdaptiveThinking: vi.fn(),
   resolveProviderBinaryThinking: vi.fn(),
   resolveProviderDefaultThinkingLevel: vi.fn(),
   resolveProviderXHighThinking: vi.fn(),
@@ -127,6 +128,7 @@ let resolveDiscordNativeChoiceContext: typeof import("./native-command-ui.js").r
 async function loadDiscordThinkAutocompleteModulesForTest() {
   vi.resetModules();
   vi.doMock("../../../../src/plugins/provider-thinking.js", () => ({
+    resolveProviderAdaptiveThinking: providerThinkingMocks.resolveProviderAdaptiveThinking,
     resolveProviderBinaryThinking: providerThinkingMocks.resolveProviderBinaryThinking,
     resolveProviderDefaultThinkingLevel: providerThinkingMocks.resolveProviderDefaultThinkingLevel,
     resolveProviderXHighThinking: providerThinkingMocks.resolveProviderXHighThinking,
@@ -143,6 +145,7 @@ async function loadDiscordThinkAutocompleteModulesForTest() {
 describe("discord native /think autocomplete", () => {
   beforeAll(async () => {
     providerThinkingMocks.resolveProviderBinaryThinking.mockReturnValue(undefined);
+    providerThinkingMocks.resolveProviderAdaptiveThinking.mockReturnValue(undefined);
     providerThinkingMocks.resolveProviderDefaultThinkingLevel.mockReturnValue(undefined);
     providerThinkingMocks.resolveProviderXHighThinking.mockImplementation(({ provider, context }) =>
       provider === "openai-codex" && ["gpt-5.4", "gpt-5.4-pro"].includes(context.modelId)
@@ -170,6 +173,8 @@ describe("discord native /think autocomplete", () => {
     resolveConfiguredBindingRouteMock.mockReturnValue(createUnboundConfiguredRouteResult());
     providerThinkingMocks.resolveProviderBinaryThinking.mockReset();
     providerThinkingMocks.resolveProviderBinaryThinking.mockReturnValue(undefined);
+    providerThinkingMocks.resolveProviderAdaptiveThinking.mockReset();
+    providerThinkingMocks.resolveProviderAdaptiveThinking.mockReturnValue(undefined);
     providerThinkingMocks.resolveProviderDefaultThinkingLevel.mockReset();
     providerThinkingMocks.resolveProviderDefaultThinkingLevel.mockReturnValue(undefined);
     providerThinkingMocks.resolveProviderXHighThinking.mockReset();
@@ -258,6 +263,7 @@ describe("discord native /think autocomplete", () => {
     });
     const values = choices.map((choice) => choice.value);
     expect(values).toContain("xhigh");
+    expect(values).not.toContain("adaptive");
   });
 
   it("falls back when a configured binding is unavailable", async () => {