feat(opencode): wire v2 MCP tools, deepseek reasoning variants, and run usage display

- mcp/v2: adapt the V1 MCP client to the core V2 MCP interface and reuse the
  shared catalog call semantics.
- provider/transform: share the deepseek toggle+effort variant combination and
  single-source the official deepseek transport predicate.
- cli run: show cache-token usage in summaries.
- tests: disable models.dev fetching (fixture-backed) and fix native LLM test
  isolation.

Author: See U

packages/opencode/src/cli/cmd/run/session-data.ts

@@ -153,11 +153,14 @@ function formatUsage(
   const text =
     limit && limit > 0 ? `${Locale.number(total)} (${Math.round((total / limit) * 100)}%)` : Locale.number(total)
 
+  const cache = (tokens?.cache?.read ?? 0) > 0 ? ` · cache ${Locale.number(tokens?.cache?.read ?? 0)}` : ""
+  const usage = `${text}${cache}`
+
   if (typeof cost === "number" && cost > 0) {
-    return `${text} · ${money.format(cost)}`
+    return `${usage} · ${money.format(cost)}`
   }
 
-  return text
+  return usage
 }
 
 export function formatError(error: {

packages/opencode/src/cli/cmd/run/turn-summary.ts

@@ -6,17 +6,20 @@ export function turnSummaryCommit(input: {
   agent: string
   model: string
   duration: string
+  cachePercent?: number
   messageID?: string
 }): StreamCommit {
+  const cache = input.cachePercent !== undefined ? ` · cache ${input.cachePercent}%` : ""
   return {
     kind: "system",
-    text: `▣ ${input.agent} · ${input.model} · ${input.duration}`,
+    text: `▣ ${input.agent} · ${input.model} · ${input.duration}${cache}`,
     phase: "final",
     source: "system",
     summary: {
       agent: input.agent,
       model: input.model,
       duration: input.duration,
+      cachePercent: input.cachePercent,
     },
     messageID: input.messageID,
   }
@@ -36,12 +39,19 @@ export function messageTurnSummaryCommit(
     return
   }
 
+  // V1 token accounting splits prompt tokens: input is non-cached, cache.read
+  // is the cached share — DeepSeek prices cache hits 50-120x cheaper.
+  const cacheRead = info.tokens?.cache?.read
+  const promptTokens = cacheRead !== undefined ? cacheRead + (info.tokens?.cache?.write ?? 0) + (info.tokens?.input ?? 0) : 0
+  const cachePercent = cacheRead !== undefined && cacheRead > 0 && promptTokens > 0 ? Math.round((cacheRead / promptTokens) * 100) : undefined
+
   const model = providers?.find((item) => item.id === info.providerID)?.models[info.modelID]?.name
 
   return turnSummaryCommit({
     agent: Locale.titlecase(info.agent),
     model: model ?? info.modelID,
     duration: Locale.duration(completed - info.time.created),
+    cachePercent,
     messageID: info.id,
   })
 }

packages/opencode/src/cli/cmd/run/types.ts

@@ -101,6 +101,7 @@ export type TurnSummary = {
   agent: string
   model: string
   duration: string
+  cachePercent?: number
 }
 
 export type ScrollbackOptions = {

packages/opencode/src/mcp/catalog.ts

@@ -51,20 +51,7 @@ export function convertTool(mcpTool: MCPToolDef, client: Client, timeout?: numbe
     description: mcpTool.description ?? "",
     inputSchema: jsonSchema(inputSchema),
     execute: async (args: unknown, options) => {
-      const result = await client.callTool(
-        {
-          name: mcpTool.name,
-          arguments: (args || {}) as Record<string, unknown>,
-        },
-        CallToolResultSchema,
-        {
-          resetTimeoutOnProgress: true,
-          signal: options.abortSignal,
-          timeout,
-          // The MCP SDK only sends a progress token when this hook is present, enabling timeout resets.
-          onprogress: () => {},
-        },
-      )
+      const result = await callTool(client, mcpTool.name, (args || {}) as Record<string, unknown>, timeout, options.abortSignal)
       if (result.isError)
         throw new Error(
           result.content
@@ -82,6 +69,28 @@ export function convertTool(mcpTool: MCPToolDef, client: Client, timeout?: numbe
   })
 }
 
+// Shared MCP tool-call invocation used by both the V1 `convertTool` path and the V2 host bridge
+// (`@/mcp/v2`). Keeping the call options in one place prevents drift between the two consumers.
+export function callTool(
+  client: Client,
+  name: string,
+  args: Record<string, unknown>,
+  timeout?: number,
+  signal?: AbortSignal,
+) {
+  return client.callTool(
+    { name, arguments: args },
+    CallToolResultSchema,
+    {
+      resetTimeoutOnProgress: true,
+      signal,
+      timeout,
+      // The MCP SDK only sends a progress token when this hook is present, enabling timeout resets.
+      onprogress: () => {},
+    },
+  )
+}
+
 export function fetch<T extends { name: string }>(
   clientName: string,
   client: Client,

packages/opencode/src/mcp/v2.ts

@@ -0,0 +1,43 @@
+import { Effect, Layer } from "effect"
+import { makeGlobalNode } from "@opencode-ai/core/effect/app-node"
+import { MCP } from "@opencode-ai/core/tool/mcp"
+import { MCP as MCPV1 } from "@/mcp"
+import { McpCatalog } from "@/mcp/catalog"
+
+// Adapts the existing V1 MCP client to the core V2 MCP interface so MCP tools register into the V2
+// tool registry. Core stays free of the MCP wire protocol; this module is the host-side bridge.
+// Note: cancellation (abort signal) is not plumbed through the core `MCP.call` interface yet, so
+// `McpCatalog.callTool` is invoked without a signal here.
+const layer = Layer.effect(
+  MCP.Service,
+  Effect.gen(function* () {
+    const mcp = yield* MCPV1.Service
+    return MCP.Service.of({
+      tools: () =>
+        Effect.gen(function* () {
+          const tools = yield* mcp.tools()
+          return Object.entries(tools).map(([name, entry]) => ({
+            name,
+            description: entry.def.description ?? "",
+            inputSchema: (entry.def.inputSchema ?? {}) as Record<string, unknown>,
+          }))
+        }),
+      call: (name, args) =>
+        Effect.gen(function* () {
+          const tools = yield* mcp.tools()
+          const entry = tools[name]
+          if (!entry) return yield* Effect.fail(new Error(`MCP tool not found: ${name}`))
+          const result = yield* Effect.tryPromise({
+            try: () => McpCatalog.callTool(entry.client, entry.def.name, args, entry.timeout),
+            catch: (error) => (error instanceof Error ? error : new Error(String(error))),
+          })
+          return {
+            content: (result.content ?? []) as MCP.ToolResultContent[],
+            isError: result.isError === true,
+          }
+        }),
+    })
+  }),
+)
+
+export const node = makeGlobalNode({ service: MCP.Service, layer, deps: [MCPV1.node] })

packages/opencode/src/provider/transform.ts

@@ -566,6 +566,26 @@ export function topK(model: Provider.Model) {
 }
 
 const WIDELY_SUPPORTED_EFFORTS = ["low", "medium", "high"]
+// DeepSeek V4 effort tiers on the official API. `low`/`xhigh` are compatibility
+// values the server maps (low→high on v4-pro, xhigh→max), so only tiers the
+// selected model actually honors are exposed. Flash supports all three; pro
+// honors high/max until it gains the full set in early Aug 2026.
+// See https://api-docs.deepseek.com/guides/thinking_mode
+function deepseekV4Efforts(apiId: string): string[] {
+  return apiId.toLowerCase().includes("deepseek-v4-flash") ? ["low", "high", "max"] : ["high", "max"]
+}
+
+// DeepSeek's own OpenAI-compatible endpoint (api.deepseek.com) is the only
+// transport that honors the native `thinking` object and flash's low tier;
+// mirrors keep their own toggle surface (e.g. DashScope's enable_thinking).
+function isDeepseekV4Official(model: { providerID: string; api: { npm: string; id: string } }) {
+  return (
+    model.providerID === "deepseek" &&
+    model.api.npm === "@ai-sdk/openai-compatible" &&
+    model.api.id.toLowerCase().includes("deepseek-v4")
+  )
+}
+
 const OPENAI_EFFORTS = ["none", "minimal", ...WIDELY_SUPPORTED_EFFORTS, "xhigh"]
 const OPENAI_GPT5_1_EFFORTS = ["none", ...WIDELY_SUPPORTED_EFFORTS]
 const OPENAI_GPT5_2_PLUS_EFFORTS = [...OPENAI_GPT5_1_EFFORTS, "xhigh"]
@@ -926,10 +946,14 @@ export function variants(model: Provider.Model): Record<string, Record<string, a
       if (model.api.id.toLowerCase().includes("north-mini-code")) {
         return Object.fromEntries(["none", "high"].map((effort) => [effort, { reasoningEffort: effort }]))
       }
-      const efforts = [...WIDELY_SUPPORTED_EFFORTS]
       if (model.api.id.toLowerCase().includes("deepseek-v4")) {
-        efforts.push("max")
+        // Official API exposes the native thinking toggle and (flash) the low
+        // tier; mirrors share the model's high/max effort surface but not the
+        // official-only toggle and low tier.
+        const efforts = isDeepseekV4Official(model) ? deepseekV4Efforts(model.api.id) : ["high", "max"]
+        return toggleAndEffort(model, effortVariants(model, efforts), isDeepseekV4Official(model))
       }
+      const efforts = [...WIDELY_SUPPORTED_EFFORTS]
       return Object.fromEntries(efforts.map((effort) => [effort, { reasoningEffort: effort }]))
 
     case "@ai-sdk/azure":
@@ -1203,6 +1227,15 @@ export function options(input: {
     }
   }
 
+  // DeepSeek V4 thinking mode defaults to enabled, but send the native toggle
+  // explicitly: the docs require an explicit `thinking.type` when combining
+  // with `response_format`, and explicit beats implicit if defaults ever change.
+  // Variants may override this (none → thinking.type disabled), since they are
+  // merged over these options at request time.
+  if (isDeepseekV4Official(input.model)) {
+    result["thinking"] = { type: "enabled" }
+  }
+
   if (input.model.providerID === "meta" && input.model.api.npm === "@ai-sdk/openai") {
     result["reasoningSummary"] = "auto"
     result["include"] = INCLUDE_ENCRYPTED_REASONING
@@ -1645,9 +1678,23 @@ export function reasoningVariants(model: ModelsDev.Model, target: Provider.Model
   if (options.length === 0) return {}
 
   const effort = options.find((option) => option.type === "effort")
-  if (effort) return effortVariants(target, effort.values)
-
   const toggle = options.some((option) => option.type === "toggle")
+  if (effort) {
+    let values = effort.values
+    // models.dev lists [high, max] for deepseek-v4-flash, but the official API
+    // also honors `low` — expose the full tier set so the fast lane can go faster.
+    if (isDeepseekV4Official(target)) {
+      values = unique([...deepseekV4Efforts(target.api.id), ...values])
+    }
+    const variants = effortVariants(target, values)
+    // Unsupported effort controls yield no variants (metadata-declared effort
+    // is not replaced by heuristic fallback); a declared toggle still applies.
+    if (Object.keys(variants).length === 0) return toggle ? nonEmptyVariants(reasoningToggle(target)) : {}
+    // mergeDeep (not spread) so toggle layers keep their own keys where effort
+    // variants share one — e.g. deepseek-v4 "high" carries thinking.enabled.
+    return toggleAndEffort(target, variants, toggle)
+  }
+
   const budget = options.find((option) => option.type === "budget_tokens")
   if (!budget) return toggle ? nonEmptyVariants(reasoningToggle(target)) : undefined
 
@@ -1690,17 +1737,33 @@ function nonEmptyVariants(variants: NonNullable<Provider.Model["variants"]>): Pr
   return Object.keys(variants).length > 0 ? variants : undefined
 }
 
+// Combine the native thinking toggle with effort variants when both apply. mergeDeep (not spread)
+// keeps the toggle's own keys where an effort variant shares one — e.g. deepseek-v4 "high"
+// carries thinking.enabled.
+function toggleAndEffort(
+  model: Provider.Model,
+  variants: NonNullable<Provider.Model["variants"]>,
+  toggle: boolean,
+): NonNullable<Provider.Model["variants"]> {
+  return toggle ? mergeDeep(reasoningToggle(model), variants) : variants
+}
+
 function reasoningToggle(model: Provider.Model): NonNullable<Provider.Model["variants"]> {
   if (model.api.npm === "@ai-sdk/alibaba")
     return {
       none: { enableThinking: false },
       high: { enableThinking: true },
     }
-  if (model.api.npm === "@ai-sdk/cohere")
+  if (model.api.npm === "@ai-sdk/cohere" || isDeepseekV4Official(model)) {
+    // DeepSeek V4 toggles thinking via the native `thinking` object on the
+    // official API; non-thinking mode is the fast lane for simple tasks.
+    // Mirrors serving deepseek-v4 keep their own toggle surface (e.g.
+    // DashScope's enable_thinking), so stay official-only.
     return {
       none: { thinking: { type: "disabled" } },
       high: { thinking: { type: "enabled" } },
     }
+  }
   return {}
 }
 

packages/opencode/src/server/routes/instance/httpapi/server.ts

@@ -61,6 +61,7 @@ import { PtyTicket } from "@opencode-ai/core/pty/ticket"
 import { Ripgrep } from "@opencode-ai/core/ripgrep"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionV2 } from "@opencode-ai/core/session"
+import { SubagentExecutor } from "@opencode-ai/core/subagent/executor"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
 import * as SessionExecutionLocal from "@opencode-ai/core/session/execution/local"
 import { lazy } from "@/util/lazy"
@@ -97,6 +98,8 @@ import { sessionHandlers } from "./handlers/session"
 import { tuiHandlers } from "./handlers/tui"
 import { handlers } from "@opencode-ai/server/handlers"
 import { buildLocationServiceMap, LocationServiceMap } from "@opencode-ai/core/location-services"
+import { MCP as MCPTool } from "@opencode-ai/core/tool/mcp"
+import * as MCPV2 from "@/mcp/v2"
 import { layer as locationLayer } from "@opencode-ai/server/location"
 import { sessionLocationLayer } from "@opencode-ai/server/middleware/session-location"
 import { PtyEnvironment } from "@opencode-ai/server/pty-environment"
@@ -263,7 +266,7 @@ const app = LayerNode.group([
 export function createRoutes(
   corsOptions?: CorsOptions,
 ): Layer.Layer<never, EffectConfig.ConfigError, RouteRequirements> {
-  const locationServiceMapV2 = buildLocationServiceMap()
+  const locationServiceMapV2 = buildLocationServiceMap([[MCPTool.node, MCPV2.node]])
 
   return Layer.mergeAll(
     rootApiRoutes,
@@ -288,7 +291,7 @@ export function createRoutes(
     Layer.provide(locationLayer),
     Layer.provide(PtyEnvironment.layer),
     Layer.provide(
-      AppNodeBuilderV1.build(SessionV2.node, [
+      AppNodeBuilderV1.build(LayerNode.group([SessionV2.node, SubagentExecutor.node]), [
         [LocationServiceMap.node, locationServiceMapV2],
         [SessionExecution.node, SessionExecutionLocal.node],
       ]),

packages/opencode/test/preload.ts

@@ -36,6 +36,7 @@ process.env["XDG_CACHE_HOME"] = path.join(dir, "cache")
 process.env["XDG_CONFIG_HOME"] = path.join(dir, "config")
 process.env["XDG_STATE_HOME"] = path.join(dir, "state")
 process.env["OPENCODE_MODELS_PATH"] = path.join(import.meta.dir, "tool", "fixtures", "models-api.json")
+process.env["OPENCODE_DISABLE_MODELS_FETCH"] = "true"
 process.env["OPENCODE_EXPERIMENTAL_EVENT_SYSTEM"] = "true"
 process.env["OPENCODE_EXPERIMENTAL_WORKSPACES"] = "true"