merge main into master: include thinking/effort fixes + usage viewer

main has all the same setup.sh / claude-copilot.sh / README / .gitignore /
bun.lock improvements as master's aa4bdaf, plus:
- adaptive→enabled thinking translation (avoids upstream 400 on opus-4.7)
- opus-4.7 effort cap opened to low/medium/high/xhigh/max
- /usage/view local HTML dashboard with auto-refresh

Author: godlockin

src/routes/messages/non-stream-translation.ts

@@ -1,4 +1,8 @@
+import consola from "consola"
+
+import { isClaudeOpus47Model, resolveModelId } from "~/lib/models"
 import {
+  sanitizeReasoningEffortForModel,
   type ChatCompletionResponse,
   type ChatCompletionsPayload,
   type ContentPart,
@@ -40,26 +44,228 @@ export function translateToOpenAI(
     stream: payload.stream,
     temperature: payload.temperature,
     top_p: payload.top_p,
+    thinking: translateThinking(payload),
+    output_config: translateOutputConfig(payload),
+    reasoning_effort: translateReasoningEffort(payload),
     user: payload.metadata?.user_id,
     tools: translateAnthropicToolsToOpenAI(payload.tools),
     tool_choice: translateAnthropicToolChoiceToOpenAI(payload.tool_choice),
   }
 }
 
+function isClaudeModel(modelId: string): boolean {
+  return modelId.startsWith("claude-")
+}
+
+type ClaudeOpus47Effort = NonNullable<
+  NonNullable<ChatCompletionsPayload["output_config"]>["effort"]
+>
+
+// Per-model effort caps. Upstream rejects efforts above the model's tier.
+// TODO: keep in sync with the mirror in services/copilot/create-chat-completions.ts.
+// 2026-04 probe: upstream now accepts low/medium/high/xhigh/max for opus-4.7
+// (and silently ignores unknown values), so the cap is opened up. Keep the
+// helper in place so we can re-tighten without restructuring callers.
+const OPUS_47_ALLOWED_EFFORTS: Array<ClaudeOpus47Effort> = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+]
+
+function getAllowedClaudeEfforts(modelId: string): Array<ClaudeOpus47Effort> {
+  if (isClaudeOpus47Model(modelId)) {
+    return OPUS_47_ALLOWED_EFFORTS
+  }
+  return []
+}
+
+function capClaudeEffort(
+  modelId: string,
+  effort: ClaudeOpus47Effort | undefined,
+): ClaudeOpus47Effort | undefined {
+  if (!effort) {
+    return undefined
+  }
+  const allowed = getAllowedClaudeEfforts(modelId)
+  if (allowed.length === 0) {
+    return effort
+  }
+  if (allowed.includes(effort)) {
+    return effort
+  }
+  const capped = allowed.at(-1)
+  consola.warn(
+    `[${modelId}] effort "${effort}" exceeds cap; downgraded to "${capped}"`,
+  )
+  return capped
+}
+
+function normalizeClaudeEffort(
+  value: string | undefined,
+): ClaudeOpus47Effort | undefined {
+  switch (value?.toLowerCase()) {
+    case "low": {
+      return "low"
+    }
+    case "medium": {
+      return "medium"
+    }
+    case "high": {
+      return "high"
+    }
+    case "xhigh": {
+      return "xhigh"
+    }
+    case "max": {
+      return "max"
+    }
+    default: {
+      return undefined
+    }
+  }
+}
+
+function getClaudeOpus47Effort(
+  payload: AnthropicMessagesPayload,
+): ClaudeOpus47Effort | undefined {
+  const explicitEffort = normalizeClaudeEffort(payload.reasoning_effort)
+  if (explicitEffort) {
+    return explicitEffort
+  }
+
+  if (payload.thinking?.type !== "enabled") {
+    return undefined
+  }
+
+  const budgetTokens = payload.thinking.budget_tokens
+  if (budgetTokens === undefined) {
+    return "medium"
+  }
+
+  if (budgetTokens <= 2_048) {
+    return "low"
+  }
+
+  if (budgetTokens <= 8_192) {
+    return "medium"
+  }
+
+  if (budgetTokens <= 24_576) {
+    return "high"
+  }
+
+  return "xhigh"
+}
+
+function translateThinking(
+  payload: AnthropicMessagesPayload,
+): ChatCompletionsPayload["thinking"] {
+  const modelId = translateModelName(payload.model)
+
+  if (!isClaudeOpus47Model(modelId)) {
+    return undefined
+  }
+
+  const t = payload.thinking
+  if (!t) {
+    return undefined
+  }
+
+  // Upstream Copilot opus-4.7 only accepts {type: "enabled"} (no "adaptive",
+  // no "disabled"). The Anthropic schema admits "enabled" | "adaptive"; we
+  // coerce both to "enabled" so legacy clients sending "adaptive" keep working.
+  return t.budget_tokens === undefined ?
+      { type: "enabled" }
+    : { type: "enabled", budget_tokens: t.budget_tokens }
+}
+
+function translateOutputConfig(
+  payload: AnthropicMessagesPayload,
+): ChatCompletionsPayload["output_config"] {
+  const modelId = translateModelName(payload.model)
+
+  if (!isClaudeOpus47Model(modelId)) {
+    return undefined
+  }
+
+  const raw = getClaudeOpus47Effort(payload)
+  const capped = capClaudeEffort(modelId, raw)
+
+  return capped ? { effort: capped } : undefined
+}
+
+function translateReasoningEffort(
+  payload: AnthropicMessagesPayload,
+): ChatCompletionsPayload["reasoning_effort"] {
+  const modelId = translateModelName(payload.model)
+
+  if (isClaudeModel(modelId)) {
+    return undefined
+  }
+
+  if (payload.reasoning_effort) {
+    return sanitizeReasoningEffortForModel(
+      modelId,
+      normalizeReasoningEffort(payload.reasoning_effort),
+    )
+  }
+
+  if (payload.thinking?.type !== "enabled") {
+    return undefined
+  }
+
+  const budgetTokens = payload.thinking.budget_tokens
+  if (budgetTokens === undefined) {
+    return "medium"
+  }
+
+  if (budgetTokens <= 2_048) {
+    return "low"
+  }
+
+  if (budgetTokens <= 8_192) {
+    return "medium"
+  }
+
+  if (budgetTokens <= 24_576) {
+    return sanitizeReasoningEffortForModel(modelId, "high")
+  }
+
+  return sanitizeReasoningEffortForModel(modelId, "xhigh")
+}
+
+function normalizeReasoningEffort(
+  value: string,
+): ChatCompletionsPayload["reasoning_effort"] {
+  switch (value.toLowerCase()) {
+    case "none": {
+      return "none"
+    }
+    case "low": {
+      return "low"
+    }
+    case "medium": {
+      return "medium"
+    }
+    case "high": {
+      return "high"
+    }
+    case "xhigh": {
+      return "xhigh"
+    }
+    case "max": {
+      return "max"
+    }
+    default: {
+      return undefined
+    }
+  }
+}
+
 function translateModelName(model: string): string {
-  // Claude Code subagent requests use date-suffixed model names (e.g. claude-opus-4-20250514)
-  // which Copilot doesn't support. Map them to the latest supported versions.
-  if (model.startsWith("claude-haiku-4-") || model === "claude-haiku-4") {
-    return "claude-haiku-4.5"
-  } else if (
-    model.startsWith("claude-sonnet-4-")
-    || model === "claude-sonnet-4"
-  ) {
-    return "claude-sonnet-4.6"
-  } else if (model.startsWith("claude-opus-4-") || model === "claude-opus-4") {
-    return "claude-opus-4.7"
-  }
-  return model
+  return resolveModelId(model)
 }
 
 function translateAnthropicMessagesToOpenAI(