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/switcher.ts

@@ -53,35 +53,7 @@ function normalizeModelID(modelID: string): string {
   return modelID.replace(/\.(\d+)/g, "-$1")
 }
 
-/**
- * Resolves proxy providers (like github-copilot) to their underlying provider.
- * This allows GitHub Copilot to inherit thinking configurations from the actual
- * model provider (Anthropic, Google, OpenAI).
- *
- * @example
- * resolveProvider("github-copilot", "claude-opus-4-6") // "anthropic"
- * resolveProvider("github-copilot", "gemini-3-pro") // "google"
- * resolveProvider("github-copilot", "gpt-5.2") // "openai"
- * resolveProvider("anthropic", "claude-opus-4-6") // "anthropic" (unchanged)
- */
-function resolveProvider(providerID: string, modelID: string): string {
-  // GitHub Copilot is a proxy - infer actual provider from model name
-  if (providerID === "github-copilot") {
-    const modelLower = modelID.toLowerCase()
-    if (modelLower.includes("claude")) return "anthropic"
-    if (modelLower.includes("gemini")) return "google"
-    if (
-      modelLower.includes("gpt") ||
-      modelLower.includes("o1") ||
-      modelLower.includes("o3")
-    ) {
-      return "openai"
-    }
-  }
 
-  // Direct providers or unknown - return as-is
-  return providerID
-}
 
 // Maps model IDs to their "high reasoning" variant (internal convention)
 // For OpenAI models, this signals that reasoning_effort should be set to "high"
@@ -116,71 +88,6 @@ const HIGH_VARIANT_MAP: Record<string, string> = {
 
 const ALREADY_HIGH: Set<string> = new Set(Object.values(HIGH_VARIANT_MAP))
 
-export const THINKING_CONFIGS = {
-  anthropic: {
-    thinking: {
-      type: "enabled",
-      budgetTokens: 64000,
-    },
-    maxTokens: 128000,
-  },
-  "google-vertex-anthropic": {
-    thinking: {
-      type: "enabled",
-      budgetTokens: 64000,
-    },
-    maxTokens: 128000,
-  },
-  "amazon-bedrock": {
-    reasoningConfig: {
-      type: "enabled",
-      budgetTokens: 32000,
-    },
-    maxTokens: 64000,
-  },
-  google: {
-    providerOptions: {
-      google: {
-        thinkingConfig: {
-          thinkingLevel: "HIGH",
-        },
-      },
-    },
-  },
-  "google-vertex": {
-    providerOptions: {
-      "google-vertex": {
-        thinkingConfig: {
-          thinkingLevel: "HIGH",
-        },
-      },
-    },
-  },
-  openai: {
-    reasoning_effort: "high",
-  },
-  "zai-coding-plan": {
-    providerOptions: {
-      "zai-coding-plan": {
-        extra_body: {
-          thinking: {
-            type: "disabled",
-          },
-        },
-      },
-    },
-  },
-} as const satisfies Record<string, Record<string, unknown>>
-
-const THINKING_CAPABLE_MODELS = {
-  anthropic: ["claude-sonnet-4", "claude-opus-4", "claude-3"],
-  "google-vertex-anthropic": ["claude-sonnet-4", "claude-opus-4", "claude-3"],
-  "amazon-bedrock": ["claude", "anthropic"],
-  google: ["gemini-2", "gemini-3"],
-  "google-vertex": ["gemini-2", "gemini-3"],
-  openai: ["gpt-5", "o1", "o3"],
-  "zai-coding-plan": ["glm"],
-} as const satisfies Record<string, readonly string[]>
 
 export function getHighVariant(modelID: string): string | null {
   const normalized = normalizeModelID(modelID)
@@ -207,37 +114,4 @@ export function isAlreadyHighVariant(modelID: string): boolean {
   return ALREADY_HIGH.has(base) || base.endsWith("-high")
 }
 
-type ThinkingProvider = keyof typeof THINKING_CONFIGS
 
-function isThinkingProvider(provider: string): provider is ThinkingProvider {
-  return provider in THINKING_CONFIGS
-}
-
-export function getThinkingConfig(
-  providerID: string,
-  modelID: string
-): Record<string, unknown> | null {
-  const normalized = normalizeModelID(modelID)
-  const { base } = extractModelPrefix(normalized)
-
-  if (isAlreadyHighVariant(normalized)) {
-    return null
-  }
-
-  const resolvedProvider = resolveProvider(providerID, modelID)
-
-  if (!isThinkingProvider(resolvedProvider)) {
-    return null
-  }
-
-  const config = THINKING_CONFIGS[resolvedProvider]
-  const capablePatterns = THINKING_CAPABLE_MODELS[resolvedProvider]
-
-  // Check capability using base model name (without prefix)
-  const baseLower = base.toLowerCase()
-  const isCapable = capablePatterns.some((pattern) =>
-    baseLower.includes(pattern.toLowerCase())
-  )
-
-  return isCapable ? config : null
-}