feat(mcp): upgrade client SDK to v2

package.json

@@ -154,7 +154,6 @@
     "pacote@21.5.0": "patches/pacote@21.5.0.patch",
     "@ai-sdk/google@3.0.73": "patches/@ai-sdk%2Fgoogle@3.0.73.patch",
     "@pierre/trees@1.0.0-beta.4": "patches/@pierre%2Ftrees@1.0.0-beta.4.patch",
-    "@modelcontextprotocol/sdk@1.29.0": "patches/@modelcontextprotocol%2Fsdk@1.29.0.patch",
     "effect@4.0.0-beta.83": "patches/effect@4.0.0-beta.83.patch",
     "@tanstack/virtual-core@3.17.3": "patches/@tanstack%2Fvirtual-core@3.17.3.patch"
   }

packages/opencode/package.json

@@ -30,6 +30,7 @@
   },
   "devDependencies": {
     "@babel/core": "7.28.4",
+    "@modelcontextprotocol/server": "2.0.0-beta.5",
     "@octokit/webhooks-types": "7.6.1",
     "@opencode-ai/core": "workspace:*",
     "@opencode-ai/http-recorder": "workspace:*",
@@ -80,7 +81,7 @@
     "@effect/platform-node": "catalog:",
     "@ff-labs/fff-bun": "0.9.4",
     "@gitlab/opencode-gitlab-auth": "1.3.3",
-    "@modelcontextprotocol/sdk": "1.29.0",
+    "@modelcontextprotocol/client": "2.0.0-beta.5",
     "@octokit/graphql": "9.0.2",
     "@octokit/rest": "catalog:",
     "@openauthjs/openauth": "catalog:",

packages/opencode/src/cli/cmd/mcp.ts

@@ -2,13 +2,10 @@ import { cmd } from "./cmd"
 import { ConfigV1 } from "@opencode-ai/core/v1/config/config"
 import { effectCmd } from "../effect-cmd"
 import { Cause } from "effect"
-import { Client } from "@modelcontextprotocol/sdk/client/index.js"
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
-import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js"
-import { LATEST_PROTOCOL_VERSION } from "@modelcontextprotocol/sdk/types.js"
+import { Client, StreamableHTTPClientTransport, UnauthorizedError } from "@modelcontextprotocol/client"
 import * as prompts from "@clack/prompts"
 import { UI } from "../ui"
-import { MCP } from "../../mcp"
+import { CLIENT_OPTIONS, MCP } from "../../mcp"
 import { McpAuth } from "../../mcp/auth"
 import { McpOAuthProvider } from "../../mcp/oauth-provider"
 import { Config } from "@/config/config"
@@ -731,107 +728,52 @@ export const McpDebugCommand = effectCmd({
       const spinner = prompts.spinner()
       spinner.start("Testing connection...")
 
-      // Test basic HTTP connectivity first
-      try {
-        const response = await fetch(serverConfig.url, {
-          method: "POST",
-          headers: {
-            ...serverConfig.headers,
-            "Content-Type": "application/json",
-            Accept: "application/json, text/event-stream",
+      const oauthConfig = typeof serverConfig.oauth === "object" ? serverConfig.oauth : undefined
+      let authorizationUrl: URL | undefined
+      const authProvider = new McpOAuthProvider(
+        serverName,
+        serverConfig.url,
+        {
+          clientId: oauthConfig?.clientId,
+          clientSecret: oauthConfig?.clientSecret,
+          scope: oauthConfig?.scope,
+          redirectUri: oauthConfig?.redirectUri,
+        },
+        {
+          onRedirect: async (url) => {
+            authorizationUrl = url
           },
-          body: JSON.stringify({
-            jsonrpc: "2.0",
-            method: "initialize",
-            params: {
-              protocolVersion: LATEST_PROTOCOL_VERSION,
-              capabilities: {},
-              clientInfo: { name: "opencode-debug", version: InstallationVersion },
-            },
-            id: 1,
-          }),
-        })
-
-        spinner.stop(`HTTP response: ${response.status} ${response.statusText}`)
-
-        // Check for WWW-Authenticate header
-        const wwwAuth = response.headers.get("www-authenticate")
-        if (wwwAuth) {
-          prompts.log.info(`WWW-Authenticate: ${wwwAuth}`)
-        }
-
-        if (response.status === 401) {
-          prompts.log.info("Initial unauthenticated check returned 401, so this server requires OAuth")
-
-          // Try to discover OAuth metadata
-          const oauthConfig = typeof serverConfig.oauth === "object" ? serverConfig.oauth : undefined
-          const authProvider = new McpOAuthProvider(
-            serverName,
-            serverConfig.url,
-            {
-              clientId: oauthConfig?.clientId,
-              clientSecret: oauthConfig?.clientSecret,
-              scope: oauthConfig?.scope,
-              redirectUri: oauthConfig?.redirectUri,
-            },
-            {
-              onRedirect: async () => {},
-            },
-            auth,
-          )
-
-          prompts.log.info("Testing OAuth flow (without completing authorization)...")
-
-          // Try creating transport with auth provider to trigger discovery
-          const transport = new StreamableHTTPClientTransport(new URL(serverConfig.url), {
-            authProvider,
-            requestInit: serverConfig.headers ? { headers: serverConfig.headers } : undefined,
-          })
+        },
+        auth,
+      )
+      const transport = new StreamableHTTPClientTransport(new URL(serverConfig.url), {
+        authProvider,
+        requestInit: serverConfig.headers ? { headers: serverConfig.headers } : undefined,
+      })
+      const client = new Client({ name: "opencode-debug", version: InstallationVersion }, CLIENT_OPTIONS)
 
-          try {
-            const client = new Client({
-              name: "opencode-debug",
-              version: InstallationVersion,
-            })
-            await client.connect(transport)
-            prompts.log.success("Connection successful (already authenticated)")
-            await client.close()
-          } catch (error) {
-            if (error instanceof UnauthorizedError) {
-              prompts.log.info(`OAuth flow triggered: ${error.message}`)
-
-              // Check if dynamic registration would be attempted
-              const clientInfo = await authProvider.clientInformation()
-              if (clientInfo) {
-                prompts.log.info(`Client ID available: ${clientInfo.client_id}`)
-              } else {
-                prompts.log.info("No client ID - dynamic registration will be attempted")
-              }
-            } else {
-              prompts.log.error(`Connection error: ${error instanceof Error ? error.message : String(error)}`)
-            }
-          }
-        } else if (response.status >= 200 && response.status < 300) {
-          prompts.log.success("Server responded successfully (no auth required or already authenticated)")
-          const body = await response.text()
-          try {
-            const json = JSON.parse(body)
-            if (json.result?.serverInfo) {
-              prompts.log.info(`Server info: ${JSON.stringify(json.result.serverInfo)}`)
-            }
-          } catch {
-            // Not JSON, ignore
-          }
+      try {
+        await client.connect(transport)
+        spinner.stop("SDK connection successful")
+        prompts.log.success(
+          `Connected using MCP ${client.getNegotiatedProtocolVersion() ?? "unknown"} (${client.getProtocolEra() ?? "unknown"})`,
+        )
+        const serverInfo = client.getServerVersion()
+        if (serverInfo) prompts.log.info(`Server info: ${JSON.stringify(serverInfo)}`)
+      } catch (error) {
+        if (error instanceof UnauthorizedError) {
+          spinner.stop("OAuth required")
+          prompts.log.info(`OAuth flow triggered: ${error.message}`)
+          if (authorizationUrl) prompts.log.info(`Authorization URL: ${authorizationUrl}`)
+          const clientInfo = await authProvider.clientInformation()
+          if (clientInfo) prompts.log.info(`Client ID available: ${clientInfo.client_id}`)
+          if (!clientInfo) prompts.log.info("No client ID - dynamic registration will be attempted")
         } else {
-          prompts.log.warn(`Unexpected status: ${response.status}`)
-          const body = await response.text().catch(() => "")
-          if (body) {
-            prompts.log.info(`Response body: ${body.substring(0, 500)}`)
-          }
+          spinner.stop("Connection failed", 1)
+          prompts.log.error(`Error: ${error instanceof Error ? error.message : String(error)}`)
         }
-      } catch (error) {
-        spinner.stop("Connection failed", 1)
-        prompts.log.error(`Error: ${error instanceof Error ? error.message : String(error)}`)
+      } finally {
+        await client.close().catch(() => {})
       }
 
       prompts.outro("Debug complete")

packages/opencode/src/mcp/auth.ts

@@ -11,6 +11,7 @@ export const Tokens = Schema.Struct({
   refreshToken: Schema.mutableKey(Schema.optional(Schema.String)),
   expiresAt: Schema.mutableKey(Schema.optional(Schema.Number)),
   scope: Schema.mutableKey(Schema.optional(Schema.String)),
+  issuer: Schema.mutableKey(Schema.optional(Schema.String)),
 })
 export type Tokens = Schema.Schema.Type<typeof Tokens>
 
@@ -19,6 +20,9 @@ export const ClientInfo = Schema.Struct({
   clientSecret: Schema.mutableKey(Schema.optional(Schema.String)),
   clientIdIssuedAt: Schema.mutableKey(Schema.optional(Schema.Number)),
   clientSecretExpiresAt: Schema.mutableKey(Schema.optional(Schema.Number)),
+  redirectUris: Schema.mutableKey(Schema.optional(Schema.Array(Schema.String))),
+  issuer: Schema.mutableKey(Schema.optional(Schema.String)),
+  configPreRegistered: Schema.mutableKey(Schema.optional(Schema.Boolean)),
 })
 export type ClientInfo = Schema.Schema.Type<typeof ClientInfo>
 

packages/opencode/src/mcp/catalog.ts

@@ -1,40 +1,8 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js"
-import {
-  CallToolResultSchema,
-  ListToolsResultSchema,
-  ToolSchema,
-  type Tool as MCPToolDef,
-} from "@modelcontextprotocol/sdk/types.js"
+import { Client, type Tool as MCPToolDef } from "@modelcontextprotocol/client"
 import { dynamicTool, jsonSchema, type JSONSchema7, type Tool } from "ai"
 import { Effect } from "effect"
 
 const DEFAULT_TIMEOUT = 30_000
-const MAX_LIST_PAGES = 1_000
-
-const TolerantListToolsResultSchema = ListToolsResultSchema.extend({
-  tools: ToolSchema.omit({ outputSchema: true }).array(),
-})
-
-export async function paginate<T, R extends { nextCursor?: string }>(
-  list: (cursor?: string) => Promise<R>,
-  items: (result: R) => T[],
-) {
-  const result: T[] = []
-  const cursors = new Set<string>()
-  let cursor: string | undefined
-
-  for (let page = 0; page < MAX_LIST_PAGES; page++) {
-    const page = await list(cursor)
-    result.push(...items(page))
-    if (page.nextCursor === undefined) return result
-    if (cursors.has(page.nextCursor)) throw new Error(`MCP list returned duplicate cursor: ${page.nextCursor}`)
-    cursors.add(page.nextCursor)
-    cursor = page.nextCursor
-  }
-
-  throw new Error(`MCP list exceeded ${MAX_LIST_PAGES} pages`)
-}
-
 export function defs(client: Client, timeout?: number) {
   return listTools(client, timeout ?? DEFAULT_TIMEOUT).pipe(Effect.catch(() => Effect.void))
 }
@@ -56,7 +24,6 @@ export function convertTool(mcpTool: MCPToolDef, client: Client, timeout?: numbe
           name: mcpTool.name,
           arguments: (args || {}) as Record<string, unknown>,
         },
-        CallToolResultSchema,
         {
           resetTimeoutOnProgress: true,
           signal: options.abortSignal,
@@ -118,53 +85,26 @@ export const sanitize = (value: string) => value.replace(/[^a-zA-Z0-9_-]/g, "_")
 
 export const toolName = (clientName: string, name: string) => sanitize(clientName) + "_" + sanitize(name)
 
-export function prompts(client: Client, timeout?: number) {
-  if (!client.getServerCapabilities()?.prompts) return Promise.resolve([])
-  return paginate(
-    (cursor) => client.listPrompts(cursor === undefined ? undefined : { cursor }, { timeout }),
-    (result) => result.prompts,
-  )
+export async function prompts(client: Client, timeout?: number) {
+  if (!client.getServerCapabilities()?.prompts) return []
+  return (await client.listPrompts(undefined, { timeout })).prompts
 }
 
-export function resources(client: Client, timeout?: number) {
-  if (!client.getServerCapabilities()?.resources) return Promise.resolve([])
-  return paginate(
-    (cursor) => client.listResources(cursor === undefined ? undefined : { cursor }, { timeout }),
-    (result) => result.resources,
-  )
+export async function resources(client: Client, timeout?: number) {
+  if (!client.getServerCapabilities()?.resources) return []
+  return (await client.listResources(undefined, { timeout })).resources
 }
 
-export function resourceTemplates(client: Client, timeout?: number) {
-  if (!client.getServerCapabilities()?.resources) return Promise.resolve([])
-  return paginate(
-    (cursor) => client.listResourceTemplates(cursor === undefined ? undefined : { cursor }, { timeout }),
-    (result) => result.resourceTemplates,
-  )
+export async function resourceTemplates(client: Client, timeout?: number) {
+  if (!client.getServerCapabilities()?.resources) return []
+  return (await client.listResourceTemplates(undefined, { timeout })).resourceTemplates
 }
 
 function listTools(client: Client, timeout: number) {
   return Effect.tryPromise({
-    try: () =>
-      paginate(
-        async (cursor) => {
-          const params = cursor === undefined ? undefined : { cursor }
-          try {
-            return await client.listTools(params, { timeout })
-          } catch (error) {
-            if (!(error instanceof Error) || !isOutputSchemaValidationError(error)) throw error
-            return client.request({ method: "tools/list", params }, TolerantListToolsResultSchema, { timeout })
-          }
-        },
-        (result) => result.tools,
-      ),
+    try: async () => (await client.listTools(undefined, { timeout })).tools,
     catch: (error) => (error instanceof Error ? error : new Error(String(error))),
   })
 }
 
-function isOutputSchemaValidationError(error: Error) {
-  return /can't resolve reference|resolves to more than one schema|outputSchema|schema.*reference|reference.*schema/i.test(
-    error.message,
-  )
-}
-
 export * as McpCatalog from "./catalog"