refactor(think-mode): migrate hook from chat.params to chat.message and remove thinking config injection

Drop provider-specific thinking config injection (THINKING_CONFIGS, getThinkingConfig,
resolveProvider) and instead rely on the provider to handle thinking based on the variant field.
Hook now fires on chat.message using model from input rather than from the message object.

🤖 Generated with assistance of [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)

src/hooks/think-mode/hook.ts

@@ -1,6 +1,6 @@
 import { detectThinkKeyword, extractPromptText } from "./detector"
-import { getHighVariant, getThinkingConfig, isAlreadyHighVariant } from "./switcher"
-import type { ThinkModeInput, ThinkModeState } from "./types"
+import { getHighVariant, isAlreadyHighVariant } from "./switcher"
+import type { ThinkModeState } from "./types"
 import { log } from "../../shared"
 
 const thinkModeState = new Map<string, ThinkModeState>()
@@ -10,53 +10,24 @@ export function clearThinkModeState(sessionID: string): void {
 }
 
 export function createThinkModeHook() {
-  function isDisabledThinkingConfig(config: Record<string, unknown>): boolean {
-    const thinkingConfig = config.thinking
-    if (
-      typeof thinkingConfig === "object" &&
-      thinkingConfig !== null &&
-      "type" in thinkingConfig &&
-      (thinkingConfig as { type?: string }).type === "disabled"
-    ) {
-      return true
-    }
-
-    const providerOptions = config.providerOptions
-    if (typeof providerOptions !== "object" || providerOptions === null) {
-      return false
-    }
-
-    return Object.values(providerOptions as Record<string, unknown>).some(
-      (providerConfig) => {
-        if (typeof providerConfig !== "object" || providerConfig === null) {
-          return false
-        }
-
-        const providerConfigMap = providerConfig as Record<string, unknown>
-        const extraBody = providerConfigMap.extra_body
-        if (typeof extraBody !== "object" || extraBody === null) {
-          return false
-        }
-
-        const extraBodyMap = extraBody as Record<string, unknown>
-        const extraThinking = extraBodyMap.thinking
-        return (
-          typeof extraThinking === "object" &&
-          extraThinking !== null &&
-          (extraThinking as { type?: string }).type === "disabled"
-        )
-      }
-    )
-  }
-
   return {
-    "chat.params": async (output: ThinkModeInput, sessionID: string): Promise<void> => {
+    "chat.message": async (
+      input: {
+        sessionID: string
+        model?: { providerID: string; modelID: string }
+      },
+      output: {
+        message: Record<string, unknown>
+        parts: Array<{ type: string; text?: string; [key: string]: unknown }>
+      }
+    ): Promise<void> => {
       const promptText = extractPromptText(output.parts)
+      const sessionID = input.sessionID
 
       const state: ThinkModeState = {
         requested: false,
         modelSwitched: false,
-        thinkingConfigInjected: false,
+        variantSet: false,
       }
 
       if (!detectThinkKeyword(promptText)) {
@@ -66,7 +37,12 @@ export function createThinkModeHook() {
 
       state.requested = true
 
-      const currentModel = output.message.model
+      if (typeof output.message.variant === "string") {
+        thinkModeState.set(sessionID, state)
+        return
+      }
+
+      const currentModel = input.model
       if (!currentModel) {
         thinkModeState.set(sessionID, state)
         return
@@ -81,14 +57,15 @@ export function createThinkModeHook() {
       }
 
       const highVariant = getHighVariant(currentModel.modelID)
-      const thinkingConfig = getThinkingConfig(currentModel.providerID, currentModel.modelID)
 
       if (highVariant) {
         output.message.model = {
           providerID: currentModel.providerID,
           modelID: highVariant,
         }
+        output.message.variant = "high"
         state.modelSwitched = true
+        state.variantSet = true
         log("Think mode: model switched to high variant", {
           sessionID,
           from: currentModel.modelID,
@@ -96,42 +73,6 @@ export function createThinkModeHook() {
         })
       }
 
-      if (thinkingConfig) {
-        const messageData = output.message as Record<string, unknown>
-        const agentThinking = messageData.thinking as { type?: string } | undefined
-        const agentProviderOptions = messageData.providerOptions
-
-        const agentDisabledThinking = agentThinking?.type === "disabled"
-        const agentHasCustomProviderOptions = Boolean(agentProviderOptions)
-
-        if (agentDisabledThinking) {
-          log("Think mode: skipping - agent has thinking disabled", {
-            sessionID,
-            provider: currentModel.providerID,
-          })
-        } else if (agentHasCustomProviderOptions) {
-          log("Think mode: skipping - agent has custom providerOptions", {
-            sessionID,
-            provider: currentModel.providerID,
-          })
-        } else if (
-          !isDisabledThinkingConfig(thinkingConfig as Record<string, unknown>)
-        ) {
-          Object.assign(output.message, thinkingConfig)
-          state.thinkingConfigInjected = true
-          log("Think mode: thinking config injected", {
-            sessionID,
-            provider: currentModel.providerID,
-            config: thinkingConfig,
-          })
-        } else {
-          log("Think mode: skipping disabled thinking config", {
-            sessionID,
-            provider: currentModel.providerID,
-          })
-        }
-      }
-
       thinkModeState.set(sessionID, state)
     },