feat: prune cloud providers and console API, complete Neuron branding sweep

2026-08-21 14:59:43 -05:00
parent f37714c9fc
commit e30d80389c
43 changed files with 324 additions and 2700 deletions
@@ -104,7 +104,7 @@ export function make(input: {
        "terminal-auth": {
          command: "opencode",
          args: ["auth", "login"],
-          label: "OpenCode Login",
+          label: "Neuron Login",
        },
      }
    }
@@ -130,7 +130,7 @@ export function make(input: {
      },
      authMethods: [authMethod],
      agentInfo: {
-        name: "OpenCode",
+        name: "Neuron",
        version: InstallationVersion,
      },
    }
@@ -874,7 +874,7 @@ const promptResponse = Effect.fn("ACP.promptResponse")(function* (

 function promptErrorMessage(error: AssistantError) {
  if ("message" in error.data && typeof error.data.message === "string") return error.data.message
-  return "OpenCode prompt failed"
+  return "Neuron prompt failed"
 }

 function sendUsageUpdate(
@@ -1067,7 +1067,7 @@ function fromUnknownError(error: unknown, service?: string): Error {
  if (isAuthRequired(error)) {
    return new ACPError.AuthRequiredError({ providerId: findProviderID(error) })
  }
-  return new ACPError.ServiceFailureError({ safeMessage: "OpenCode service failure", service })
+  return new ACPError.ServiceFailureError({ safeMessage: "Neuron service failure", service })
 }

 function isACPError(error: unknown): error is Error {
@@ -125,11 +125,11 @@ export function permissionInfo(request: PermissionRequest): PermissionInfo {

 export function permissionAlwaysLines(request: PermissionRequest): string[] {
  if (request.always.length === 1 && request.always[0] === "*") {
-    return [`This will allow ${request.permission} until OpenCode is restarted.`]
+    return [`This will allow ${request.permission} until Neuron is restarted.`]
  }

  return [
-    "This will allow the following patterns until OpenCode is restarted.",
+    "This will allow the following patterns until Neuron is restarted.",
    ...request.always.map((item) => `- ${item}`),
  ]
 }
@@ -194,7 +194,7 @@ function build(input: SplashWriterInput, kind: "entry" | "exit", ctx: Scrollback
      })
    }

-    push(lines, body_left, top, "OpenCode", right, undefined, TextAttributes.BOLD)
+    push(lines, body_left, top, "Neuron", right, undefined, TextAttributes.BOLD)
    if (input.detail) {
      push(
        lines,
@@ -55,7 +55,7 @@ export const UninstallCommand = {
    UI.empty()
    UI.println(UI.logo("  "))
    UI.empty()
-    prompts.intro("Uninstall OpenCode")
+    prompts.intro("Uninstall Neuron")

    const method = await Installation.method()
    prompts.log.info(`Installation method: ${method}`)
@@ -229,7 +229,7 @@ async function executeUninstall(method: Installation.Method, targets: RemovalTar
  }

  UI.empty()
-  prompts.log.success("Thank you for using OpenCode!")
+  prompts.log.success("Thank you for using Neuron!")
 }

 async function getShellConfigFile(): Promise<string | null> {
@@ -7,7 +7,7 @@ import { Process } from "@/util/process"

 const MANAGED_PLIST_DOMAIN = "ai.opencode.managed"

-// Keys injected by macOS/MDM into the managed plist that are not OpenCode config
+// Keys injected by macOS/MDM into the managed plist that are not Neuron config
 const PLIST_META = new Set([
  "PayloadDisplayName",
  "PayloadIdentifier",
@@ -1,19 +0,0 @@
-This is a plugin to simulate a remote environment locally. Add this to `.opencode/opencode.jsonc`:
-
-```json
-  "plugin": ["../packages/opencode/src/control-plane/dev/debug-workspace-plugin.ts"],
-```
-
-In a separate terminal, run a separate OpenCode server. This will act like a remote server and the local instance will proxy all requests to it:
-
-```
-./packages/opencode/script/run-workspace-server
-```
-
-With the plugin install, you can now run OpenCode and create a `debug` workspace type. This will create a "remote" workspace which talks to the second workspace server started above.
-
-How this works:
-
- The workspace server needs to know the workspace id and port to run. It waits for this information to be written to a file and starts the server when the data is written.
- The debug plugin writes this information in the `create` call to the workspace. So create a `debug` workspace will always kick off a new external server.
- The server script watches for file changes, so whenver you create a new `debug` workspace it will restart with the new information. This means that there is only ever one working `debug` workspace at a time; when you create a new one all previous sessions will show that it can't connect because previous debug workspaces do not exist.
@@ -1,73 +0,0 @@
-import type { Plugin } from "@opencode-ai/plugin"
-import { rename, writeFile } from "node:fs/promises"
-import { randomInt } from "node:crypto"
-import { setTimeout as sleep } from "node:timers/promises"
-
-const DEV_DATA_FILE = "/tmp/opencode-workspace-dev-data.json"
-const DEV_DATA_TEMP_FILE = `${DEV_DATA_FILE}.tmp`
-
-async function waitForHealth(port: number) {
-  const url = `http://127.0.0.1:${port}/global/health`
-  const started = Date.now()
-
-  while (Date.now() - started < 30_000) {
-    try {
-      const response = await fetch(url)
-      if (response.ok) {
-        return
-      }
-    } catch {}
-
-    await sleep(250)
-  }
-
-  throw new Error(`Timed out waiting for debug server health check at ${url}`)
-}
-
-let PORT: number | undefined
-
-async function writeDebugData(port: number, id: string, env: Record<string, string | undefined>) {
-  await writeFile(
-    DEV_DATA_TEMP_FILE,
-    JSON.stringify(
-      {
-        port,
-        id,
-        env,
-      },
-      null,
-      2,
-    ),
-  )
-
-  await rename(DEV_DATA_TEMP_FILE, DEV_DATA_FILE)
-}
-
-export const DebugWorkspacePlugin: Plugin = async ({ experimental_workspace }) => {
-  experimental_workspace.register("debug", {
-    name: "Debug",
-    description: "Create a debugging server",
-    configure(config) {
-      return config
-    },
-    async create(config, env) {
-      const port = randomInt(5000, 9001)
-      PORT = port
-
-      await writeDebugData(port, config.id, env)
-
-      await waitForHealth(port)
-    },
-    async remove(_config) {},
-    target(_config) {
-      return {
-        type: "remote",
-        url: `http://localhost:${PORT!}/`,
-      }
-    },
-  })
-
-  return {}
-}
-
-export default DebugWorkspacePlugin
@@ -43,7 +43,7 @@ export class McpOAuthProvider implements OAuthClientProvider {
  get clientMetadata(): OAuthClientMetadata {
    return {
      redirect_uris: [this.redirectUrl],
-      client_name: "OpenCode",
+      client_name: "Neuron",
      client_uri: "https://opencode.ai",
      grant_types: ["authorization_code", "refresh_token"],
      response_types: ["code"],
@@ -1,26 +0,0 @@
-import type { Hooks, PluginInput } from "@opencode-ai/plugin"
-
-export async function AzureAuthPlugin(_input: PluginInput): Promise<Hooks> {
-  const prompts = []
-  if (!process.env.AZURE_RESOURCE_NAME) {
-    prompts.push({
-      type: "text" as const,
-      key: "resourceName",
-      message: "Enter Azure Resource Name",
-      placeholder: "e.g. my-models",
-    })
-  }
-
-  return {
-    auth: {
-      provider: "azure",
-      methods: [
-        {
-          type: "api",
-          label: "API key",
-          prompts,
-        },
-      ],
-    },
-  }
-}
@@ -1,65 +0,0 @@
-import type { Hooks, PluginInput } from "@opencode-ai/plugin"
-
-export async function CloudflareWorkersAuthPlugin(_input: PluginInput): Promise<Hooks> {
-  const prompts = !process.env.CLOUDFLARE_ACCOUNT_ID
-    ? [
-        {
-          type: "text" as const,
-          key: "accountId",
-          message: "Enter your Cloudflare Account ID",
-          placeholder: "e.g. 1234567890abcdef1234567890abcdef",
-        },
-      ]
-    : []
-
-  return {
-    auth: {
-      provider: "cloudflare-workers-ai",
-      methods: [
-        {
-          type: "api",
-          label: "API key",
-          prompts,
-        },
-      ],
-    },
-  }
-}
-
-export async function CloudflareAIGatewayAuthPlugin(_input: PluginInput): Promise<Hooks> {
-  const prompts = [
-    ...(!process.env.CLOUDFLARE_ACCOUNT_ID
-      ? [
-          {
-            type: "text" as const,
-            key: "accountId",
-            message: "Enter your Cloudflare Account ID",
-            placeholder: "e.g. 1234567890abcdef1234567890abcdef",
-          },
-        ]
-      : []),
-    ...(!process.env.CLOUDFLARE_GATEWAY_ID
-      ? [
-          {
-            type: "text" as const,
-            key: "gatewayId",
-            message: "Enter your Cloudflare AI Gateway ID",
-            placeholder: "e.g. my-gateway",
-          },
-        ]
-      : []),
-  ]
-
-  return {
-    auth: {
-      provider: "cloudflare-ai-gateway",
-      methods: [
-        {
-          type: "api",
-          label: "Gateway API token",
-          prompts,
-        },
-      ],
-    },
-  }
-}
@@ -283,7 +283,7 @@ export async function DigitalOceanAuthPlugin(input: PluginInput): Promise<Hooks>
            return {
              url,
              instructions:
-                "Sign in to DigitalOcean in your browser. OpenCode will use your DigitalOcean API token directly for inference and load your Inference Routers. Re-run /connect to refresh routers later.",
+                "Sign in to DigitalOcean in your browser. Neuron will use your DigitalOcean API token directly for inference and load your Inference Routers. Re-run /connect to refresh routers later.",
              method: "auto" as const,
              async callback() {
                try {
@@ -12,15 +12,11 @@ import { ServerAuth } from "@/server/auth"
 import { CodexAuthPlugin } from "./openai/codex"
 import { Session } from "@/session/session"
 import { NamedError } from "@opencode-ai/core/util/error"
-import { ModalPlugin } from "./modal/modal"
 import { gitlabAuthPlugin as GitlabAuthPlugin } from "opencode-gitlab-auth"
 import { PoeAuthPlugin } from "opencode-poe-auth"
-import { CloudflareAIGatewayAuthPlugin, CloudflareWorkersAuthPlugin } from "./cloudflare"
-import { AzureAuthPlugin } from "./azure"
 import { DigitalOceanAuthPlugin } from "./digitalocean"
 import { XaiAuthPlugin } from "./xai"
 import { CerebrasPlugin } from "./cerebras"
-import { SnowflakeCortexAuthPlugin } from "./snowflake-cortex"
 import { Effect, Layer, Context } from "effect"
 import { EffectBridge } from "@/effect/bridge"
 import { InstanceState } from "@/effect/instance-state"
@@ -70,14 +66,9 @@ function internalPlugins(flags: RuntimeFlags.Info): PluginInstance[] {
      CodexAuthPlugin(input, {
        experimentalWebSockets: experimentalWebSocketsEnabled({ enabled: flags.experimentalWebSockets }),
      }),
-    ModalPlugin,
    GitlabAuthPlugin,
    PoeAuthPlugin,
-    CloudflareWorkersAuthPlugin,
-    CloudflareAIGatewayAuthPlugin,
-    AzureAuthPlugin,
    DigitalOceanAuthPlugin,
-    SnowflakeCortexAuthPlugin,
    XaiAuthPlugin,
    CerebrasPlugin,
  ]
@@ -1,17 +0,0 @@
-import type { Hooks } from "@opencode-ai/plugin"
-import { ModalModels } from "./models"
-
-export async function ModalPlugin(): Promise<Hooks> {
-  return {
-    provider: {
-      id: "modal",
-      async models(provider, ctx) {
-        const apiKey = ctx.auth?.type === "api" ? ctx.auth.key : process.env.MODAL_PROXY_TOKEN
-        const baseURL = Object.values(provider.models)[0]?.api.url
-        if (!apiKey || !baseURL) return {}
-
-        return ModalModels.get(baseURL, apiKey, provider.models).catch(() => ({}))
-      },
-    },
-  }
-}
@@ -1,133 +0,0 @@
-import type { Model } from "@opencode-ai/sdk/v2"
-import { Schema } from "effect"
-
-const reasoningOption = Schema.Struct({
-  type: Schema.Literal("effort"),
-  values: Schema.Array(Schema.NullOr(Schema.String)),
-})
-
-const response = Schema.Struct({
-  data: Schema.Array(
-    Schema.Struct({
-      id: Schema.String,
-      base_model_id: Schema.optional(Schema.String),
-      hugging_face_id: Schema.optional(Schema.String),
-      name: Schema.optional(Schema.String),
-      input_modalities: Schema.optional(Schema.Array(Schema.String)),
-      output_modalities: Schema.optional(Schema.Array(Schema.String)),
-      context_length: Schema.optional(Schema.Number),
-      max_output_length: Schema.optional(Schema.Number),
-      pricing: Schema.optional(
-        Schema.Struct({
-          prompt: Schema.optional(Schema.Union([Schema.String, Schema.Number])),
-          completion: Schema.optional(Schema.Union([Schema.String, Schema.Number])),
-          input_cache_read: Schema.optional(Schema.Union([Schema.String, Schema.Number])),
-        }),
-      ),
-      supported_sampling_parameters: Schema.optional(Schema.Array(Schema.String)),
-      supported_features: Schema.optional(Schema.Array(Schema.String)),
-      reasoning_options: Schema.optional(Schema.Array(reasoningOption)),
-      interleaved: Schema.optional(
-        Schema.Union([
-          Schema.Boolean,
-          Schema.Struct({
-            field: Schema.Literals(["reasoning", "reasoning_content", "reasoning_details"]),
-          }),
-        ]),
-      ),
-    }),
-  ),
-})
-
-const decode = Schema.decodeUnknownSync(response)
-
-function price(value: string | number | undefined, fallback: number) {
-  if (value === undefined) return fallback
-  const parsed = Number(value)
-  return Number.isFinite(parsed) ? parsed * 1_000_000 : fallback
-}
-
-export async function get(baseURL: string, apiKey: string, existing: Record<string, Model>) {
-  const data = await fetch(`${baseURL.replace(/\/+$/, "")}/models`, {
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-    },
-    signal: AbortSignal.timeout(3_000),
-  }).then(async (res) => {
-    if (!res.ok) throw new Error(`Failed to fetch Modal models: ${res.status}`)
-    return decode(await res.json())
-  })
-
-  return Object.fromEntries(
-    data.data.map((item) => {
-      const template = existing[item.base_model_id ?? item.hugging_face_id ?? item.id]
-      const model: Model = {
-        id: item.id,
-        providerID: "modal",
-        name: item.name ?? template?.name ?? item.id,
-        family: template?.family,
-        api: {
-          id: item.id,
-          url: baseURL,
-          npm: template?.api.npm ?? "@ai-sdk/openai-compatible",
-        },
-        status: template?.status ?? "active",
-        headers: { ...template?.headers },
-        options: { ...template?.options },
-        cost: {
-          input: price(item.pricing?.prompt, template?.cost.input ?? 0),
-          output: price(item.pricing?.completion, template?.cost.output ?? 0),
-          cache: {
-            read: price(item.pricing?.input_cache_read, template?.cost.cache.read ?? 0),
-            write: template?.cost.cache.write ?? 0,
-          },
-        },
-        limit: {
-          context: item.context_length ?? template?.limit.context ?? 0,
-          input: template?.limit.input,
-          output: item.max_output_length ?? template?.limit.output ?? 0,
-        },
-        capabilities: {
-          temperature:
-            item.supported_sampling_parameters?.includes("temperature") ?? template?.capabilities.temperature ?? false,
-          reasoning: item.supported_features?.includes("reasoning") ?? template?.capabilities.reasoning ?? false,
-          attachment:
-            item.input_modalities?.some((modality) => modality !== "text") ??
-            template?.capabilities.attachment ??
-            false,
-          toolcall: item.supported_features?.includes("tools") ?? template?.capabilities.toolcall ?? true,
-          input: {
-            text: item.input_modalities?.includes("text") ?? template?.capabilities.input.text ?? true,
-            audio: item.input_modalities?.includes("audio") ?? template?.capabilities.input.audio ?? false,
-            image: item.input_modalities?.includes("image") ?? template?.capabilities.input.image ?? false,
-            video: item.input_modalities?.includes("video") ?? template?.capabilities.input.video ?? false,
-            pdf: item.input_modalities?.includes("pdf") ?? template?.capabilities.input.pdf ?? false,
-          },
-          output: {
-            text: item.output_modalities?.includes("text") ?? template?.capabilities.output.text ?? true,
-            audio: item.output_modalities?.includes("audio") ?? template?.capabilities.output.audio ?? false,
-            image: item.output_modalities?.includes("image") ?? template?.capabilities.output.image ?? false,
-            video: item.output_modalities?.includes("video") ?? template?.capabilities.output.video ?? false,
-            pdf: item.output_modalities?.includes("pdf") ?? template?.capabilities.output.pdf ?? false,
-          },
-          interleaved: item.interleaved ?? template?.capabilities.interleaved ?? false,
-        },
-        release_date: template?.release_date ?? "",
-      }
-      model.variants =
-        item.reasoning_options === undefined
-          ? template?.variants
-          : Object.fromEntries(
-              item.reasoning_options.flatMap((option) =>
-                option.values.map((value) => {
-                  const effort = value ?? "none"
-                  return [effort, { reasoningEffort: effort }]
-                }),
-              ),
-            )
-      return [item.id, model]
-    }),
-  )
-}
-
-export * as ModalModels from "./models"
@@ -1,507 +0,0 @@
-import type { Hooks, PluginInput } from "@opencode-ai/plugin"
-import { OAUTH_DUMMY_KEY } from "../auth"
-import { InstallationVersion } from "@opencode-ai/core/installation/version"
-import { OauthCallbackPage } from "@opencode-ai/core/oauth/page"
-import { createServer } from "http"
-import open from "open"
-
-const OAUTH_CLIENT_ID = "LOCAL_APPLICATION"
-const OAUTH_CALLBACK_HOST = "127.0.0.1"
-const OAUTH_CALLBACK_PATH = "/"
-const OAUTH_TIMEOUT_MS = 5 * 60 * 1000
-const ACCESS_TOKEN_REFRESH_SKEW_MS = 120_000
-
-interface PkceCodes {
-  verifier: string
-  challenge: string
-}
-
-interface TokenResponse {
-  access_token: string
-  refresh_token?: string
-  expires_in?: number
-  token_type?: string
-}
-
-interface PendingOAuth {
-  account: string
-  state: string
-  pkce: PkceCodes
-  resolve: (tokens: TokenResponse) => void
-  reject: (error: Error) => void
-}
-
-let oauthServer: ReturnType<typeof createServer> | undefined
-let pendingOAuth: PendingOAuth | undefined
-let oauthServerPort: number | undefined
-
-function normalizeAccount(input: string) {
-  return input
-    .trim()
-    .replace(/^https?:\/\//, "")
-    .replace(/\.snowflakecomputing\.com\/?$/, "")
-    .replace(/\/+$/, "")
-}
-
-function generateRandomString(length: number) {
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~"
-  return Array.from(crypto.getRandomValues(new Uint8Array(length)))
-    .map((b) => chars[b % chars.length])
-    .join("")
-}
-
-function base64UrlEncode(buffer: ArrayBuffer) {
-  const binary = String.fromCharCode(...new Uint8Array(buffer))
-  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")
-}
-
-async function generatePKCE(): Promise<PkceCodes> {
-  const verifier = generateRandomString(64)
-  const hash = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier))
-  return {
-    verifier,
-    challenge: base64UrlEncode(hash),
-  }
-}
-
-function callbackUrl() {
-  if (!oauthServerPort) throw new Error("Snowflake OAuth callback server is not running")
-  return `http://${OAUTH_CALLBACK_HOST}:${oauthServerPort}${OAUTH_CALLBACK_PATH}`
-}
-
-export function oauthScope(role: string | undefined) {
-  if (!role) return "refresh_token"
-  return /^[-_A-Za-z0-9]+$/.test(role)
-    ? `refresh_token session:role:${role}`
-    : `refresh_token session:role-encoded:${encodeURIComponent(role)}`
-}
-
-function authHeaders() {
-  return {
-    "Content-Type": "application/x-www-form-urlencoded",
-    Accept: "application/json",
-    "User-Agent": `opencode/${InstallationVersion}`,
-  }
-}
-
-function authBasicHeader() {
-  return `Basic ${Buffer.from(`${OAUTH_CLIENT_ID}:${OAUTH_CLIENT_ID}`).toString("base64")}`
-}
-
-function buildAuthorizeUrl(account: string, role: string | undefined, state: string, pkce: PkceCodes) {
-  const scope = oauthScope(role)
-  const params = new URLSearchParams({
-    client_id: OAUTH_CLIENT_ID,
-    response_type: "code",
-    redirect_uri: callbackUrl(),
-    scope,
-    state,
-    code_challenge: pkce.challenge,
-    code_challenge_method: "S256",
-  })
-  return `https://${account}.snowflakecomputing.com/oauth/authorize?${params.toString()}`
-}
-
-async function exchangeCodeForToken(account: string, code: string, pkce: PkceCodes) {
-  const response = await fetch(`https://${account}.snowflakecomputing.com/oauth/token-request`, {
-    method: "POST",
-    headers: {
-      ...authHeaders(),
-      Authorization: authBasicHeader(),
-    },
-    body: new URLSearchParams({
-      grant_type: "authorization_code",
-      code,
-      redirect_uri: callbackUrl(),
-      client_id: OAUTH_CLIENT_ID,
-      code_verifier: pkce.verifier,
-    }).toString(),
-  })
-
-  if (!response.ok) {
-    const detail = await response.text().catch(() => "")
-    throw new Error(`Snowflake token exchange failed (${response.status})${detail ? `: ${detail}` : ""}`)
-  }
-
-  const token = (await response.json()) as TokenResponse
-  if (!token.access_token) throw new Error("Snowflake token response did not include access_token")
-  if (!token.refresh_token) {
-    throw new Error(
-      "Snowflake token response did not include refresh_token. Ensure integration issues refresh tokens and scope includes refresh_token.",
-    )
-  }
-  return token
-}
-
-async function refreshAccessToken(account: string, refreshToken: string) {
-  const response = await fetch(`https://${account}.snowflakecomputing.com/oauth/token-request`, {
-    method: "POST",
-    headers: {
-      ...authHeaders(),
-      Authorization: authBasicHeader(),
-    },
-    body: new URLSearchParams({
-      grant_type: "refresh_token",
-      refresh_token: refreshToken,
-      client_id: OAUTH_CLIENT_ID,
-    }).toString(),
-  })
-
-  if (!response.ok) {
-    const detail = await response.text().catch(() => "")
-    throw new Error(`Snowflake token refresh failed (${response.status})${detail ? `: ${detail}` : ""}`)
-  }
-
-  const token = (await response.json()) as TokenResponse
-  if (!token.access_token) throw new Error("Snowflake refresh response did not include access_token")
-  return token
-}
-
-async function startOAuthServer() {
-  if (oauthServer) return
-
-  oauthServer = createServer((req, res) => {
-    const host = req.headers.host || `${OAUTH_CALLBACK_HOST}:${oauthServerPort ?? 0}`
-    const url = new URL(req.url || "/", `http://${host}`)
-
-    if (url.pathname !== OAUTH_CALLBACK_PATH) {
-      res.writeHead(404)
-      res.end("Not found")
-      return
-    }
-
-    const state = url.searchParams.get("state")
-    const code = url.searchParams.get("code")
-    const error = url.searchParams.get("error")
-    const errorDescription = url.searchParams.get("error_description")
-
-    // CSRF guard: validate state before processing any callback
-    if (!pendingOAuth || state !== pendingOAuth.state) {
-      const message = "Invalid state - potential CSRF attack"
-      pendingOAuth?.reject(new Error(message))
-      pendingOAuth = undefined
-      res.writeHead(400, { "Content-Type": "text/html" })
-      res.end(OauthCallbackPage.error(message, { provider: "Snowflake" }))
-      return
-    }
-
-    const current = pendingOAuth
-    pendingOAuth = undefined
-
-    if (error) {
-      const message = errorDescription || error
-      current.reject(new Error(message))
-      res.writeHead(200, { "Content-Type": "text/html" })
-      res.end(OauthCallbackPage.error(message, { provider: "Snowflake" }))
-      return
-    }
-
-    if (!code) {
-      const message = "Missing authorization code"
-      current.reject(new Error(message))
-      res.writeHead(400, { "Content-Type": "text/html" })
-      res.end(OauthCallbackPage.error(message, { provider: "Snowflake" }))
-      return
-    }
-
-    exchangeCodeForToken(current.account, code, current.pkce)
-      .then((tokens) => current.resolve(tokens))
-      .catch((err) => current.reject(err instanceof Error ? err : new Error(String(err))))
-
-    res.writeHead(200, { "Content-Type": "text/html" })
-    res.end(OauthCallbackPage.success({ provider: "Snowflake" }))
-  })
-
-  await new Promise<void>((resolve, reject) => {
-    oauthServer!.listen(0, OAUTH_CALLBACK_HOST, () => {
-      const address = oauthServer!.address()
-      if (!address || typeof address === "string") {
-        reject(new Error("Unable to resolve Snowflake OAuth callback port"))
-        return
-      }
-      oauthServerPort = address.port
-      resolve()
-    })
-    oauthServer!.on("error", reject)
-  })
-}
-
-function stopOAuthServer() {
-  if (!oauthServer) return
-  oauthServer.close()
-  oauthServer = undefined
-  oauthServerPort = undefined
-}
-
-function waitForOAuthCallback(account: string, pkce: PkceCodes, state: string): Promise<TokenResponse> {
-  if (pendingOAuth) {
-    pendingOAuth.reject(new Error("Superseded by a newer Snowflake authorize request"))
-    pendingOAuth = undefined
-  }
-
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      if (!pendingOAuth) return
-      pendingOAuth = undefined
-      stopOAuthServer()
-      reject(new Error("Snowflake OAuth callback timeout - authorization took too long"))
-    }, OAUTH_TIMEOUT_MS)
-
-    pendingOAuth = {
-      account,
-      state,
-      pkce,
-      resolve: (tokens) => {
-        clearTimeout(timeout)
-        resolve(tokens)
-      },
-      reject: (error) => {
-        clearTimeout(timeout)
-        reject(error)
-      },
-    }
-  })
-}
-
-export async function SnowflakeCortexAuthPlugin(_input: PluginInput): Promise<Hooks> {
-  const prompts = [
-    {
-      type: "text" as const,
-      key: "account",
-      message: "Snowflake Account Identifier",
-      placeholder: "myorg-myaccount",
-      validate: (value: string) => (value && value.trim().length > 0 ? undefined : "Required"),
-    },
-    {
-      type: "text" as const,
-      key: "role",
-      message: "Snowflake Role (optional)",
-      placeholder: "PUBLIC",
-    },
-  ]
-
-  return {
-    auth: {
-      provider: "snowflake-cortex",
-      async loader(getAuth, _provider) {
-        let auth = await getAuth()
-        if (auth.type !== "oauth") return {}
-
-        let refreshPromise:
-          | Promise<{
-              access: string
-              refresh: string
-              expires: number
-            }>
-          | undefined
-
-        const oauth = auth as typeof auth & { refresh: string; access: string; expires: number; accountId?: string }
-
-        if (oauth.accountId && oauth.refresh && oauth.expires && oauth.expires <= Date.now()) {
-          try {
-            const tokens = await refreshAccessToken(oauth.accountId, oauth.refresh)
-            const refreshedRefresh = tokens.refresh_token || oauth.refresh
-            const refreshedExpires = Date.now() + (tokens.expires_in ?? 600) * 1000
-            await _input.client.auth
-              .set({
-                path: { id: "snowflake-cortex" },
-                body: {
-                  type: "oauth",
-                  access: tokens.access_token,
-                  refresh: refreshedRefresh,
-                  expires: refreshedExpires,
-                  ...(oauth.accountId && { accountId: oauth.accountId }),
-                },
-              })
-              .catch(() => {})
-          } catch {}
-        }
-
-        return {
-          apiKey: OAUTH_DUMMY_KEY,
-          async fetch(requestInput: RequestInfo | URL, init?: RequestInit) {
-            let currentAuth = await getAuth()
-            if (currentAuth.type !== "oauth") return fetch(requestInput, init)
-            let currentOauth = currentAuth as typeof currentAuth & {
-              refresh: string
-              access: string
-              expires: number
-              accountId?: string
-            }
-
-            if (!currentOauth.accountId) throw new Error("Snowflake OAuth auth is missing accountId")
-            const accountId = currentOauth.accountId
-
-            const refresh = async () => {
-              if (!refreshPromise) {
-                const refreshToken = currentOauth.refresh
-                refreshPromise = refreshAccessToken(accountId, refreshToken)
-                  .then(async (tokens) => {
-                    const refreshedRefresh = tokens.refresh_token || refreshToken
-                    const refreshedExpires = Date.now() + (tokens.expires_in ?? 600) * 1000
-                    await _input.client.auth
-                      .set({
-                        path: { id: "snowflake-cortex" },
-                        body: {
-                          type: "oauth",
-                          access: tokens.access_token,
-                          refresh: refreshedRefresh,
-                          expires: refreshedExpires,
-                          ...(accountId && { accountId }),
-                        },
-                      })
-                      .catch(() => {})
-                    return {
-                      access: tokens.access_token,
-                      refresh: refreshedRefresh,
-                      expires: refreshedExpires,
-                    }
-                  })
-                  .finally(() => {
-                    refreshPromise = undefined
-                  })
-              }
-
-              const refreshed = await refreshPromise
-              currentOauth = { ...currentOauth, ...refreshed }
-            }
-
-            const prepareRequest = () => {
-              const headers = new Headers(requestInput instanceof Request ? requestInput.headers : undefined)
-              if (init?.headers) {
-                const entries =
-                  init.headers instanceof Headers
-                    ? init.headers.entries()
-                    : Array.isArray(init.headers)
-                      ? init.headers
-                      : Object.entries(init.headers as Record<string, string | undefined>)
-                for (const [key, value] of entries) {
-                  if (value !== undefined) headers.set(key, String(value))
-                }
-              }
-              headers.set("authorization", `Bearer ${currentOauth.access}`)
-              headers.set("User-Agent", `opencode/${InstallationVersion}`)
-
-              let body = init?.body
-              if (body && typeof body === "string") {
-                try {
-                  const parsed = JSON.parse(body)
-                  if ("max_tokens" in parsed) {
-                    parsed.max_completion_tokens = parsed.max_tokens
-                    delete parsed.max_tokens
-                    body = JSON.stringify(parsed)
-                  }
-                } catch {}
-              }
-
-              return { ...init, headers, body }
-            }
-
-            const transformResponse = async (response: Response) => {
-              if (!response.ok && response.status === 400) {
-                try {
-                  const errorData = await response.clone().json()
-                  const errorMessage = String(errorData.message || errorData.error || "")
-                  if (errorMessage.toLowerCase().includes("conversation complete")) {
-                    return new Response(
-                      JSON.stringify({
-                        choices: [{ finish_reason: "stop", message: { content: "", role: "assistant" } }],
-                      }),
-                      { status: 200, headers: new Headers({ "content-type": "application/json" }) },
-                    )
-                  }
-                } catch {}
-              }
-
-              if (response.body && response.headers.get("content-type")?.includes("text/event-stream")) {
-                const reader = response.body.getReader()
-                const encoder = new TextEncoder()
-                const decoder = new TextDecoder()
-                const stream = new ReadableStream({
-                  async pull(ctrl) {
-                    const { done, value } = await reader.read()
-                    if (done) {
-                      ctrl.close()
-                      return
-                    }
-                    const text = decoder.decode(value, { stream: true })
-                    ctrl.enqueue(encoder.encode(text.replace(/"role"\s*:\s*""/g, '"role":"assistant"')))
-                  },
-                  cancel() {
-                    reader.cancel()
-                  },
-                })
-                return new Response(stream, { headers: response.headers, status: response.status })
-              }
-
-              return response
-            }
-
-            const expiresSoon =
-              !currentOauth.expires ||
-              !currentOauth.access ||
-              currentOauth.expires - Date.now() <= ACCESS_TOKEN_REFRESH_SKEW_MS
-
-            if (expiresSoon) await refresh()
-
-            const response = await fetch(requestInput, prepareRequest())
-
-            if (response.status === 401) {
-              await refresh()
-              return transformResponse(await fetch(requestInput, prepareRequest()))
-            }
-
-            return transformResponse(response)
-          },
-        }
-      },
-      methods: [
-        {
-          type: "oauth",
-          label: "Login with Snowflake (External Browser)",
-          prompts,
-          async authorize(inputs = {}) {
-            const account = normalizeAccount(inputs.account || "")
-            if (!account) throw new Error("Snowflake account is required")
-
-            await startOAuthServer()
-            const pkce = await generatePKCE()
-            const state = generateRandomString(64)
-            const role = (inputs.role || "").trim() || undefined
-            const url = buildAuthorizeUrl(account, role, state, pkce)
-            const callbackPromise = waitForOAuthCallback(account, pkce, state)
-            await open(url).catch(() => undefined)
-
-            return {
-              url,
-              instructions:
-                "Complete Snowflake sign-in in your browser. OpenCode will capture the OAuth callback and store the bearer token automatically.",
-              method: "auto" as const,
-              async callback() {
-                try {
-                  const tokens = await callbackPromise
-                  return {
-                    type: "success" as const,
-                    refresh: tokens.refresh_token!,
-                    access: tokens.access_token,
-                    expires: Date.now() + (tokens.expires_in ?? 600) * 1000,
-                    accountId: account,
-                  }
-                } catch {
-                  return { type: "failed" as const }
-                } finally {
-                  stopOAuthServer()
-                }
-              },
-            }
-          },
-        },
-        {
-          type: "api",
-          label: "Paste PAT or bearer token manually",
-          prompts: prompts.filter((item) => item.key === "account"),
-        },
-      ],
-    },
-  }
-}
@@ -111,14 +111,9 @@ type BundledSDK = {
 }

 const BUNDLED_PROVIDERS: Record<string, () => Promise<(opts: any) => BundledSDK>> = {
-  "@ai-sdk/amazon-bedrock": () => import("@ai-sdk/amazon-bedrock").then((m) => m.createAmazonBedrock),
-  "@ai-sdk/amazon-bedrock/mantle": () => import("@ai-sdk/amazon-bedrock/mantle").then((m) => m.createBedrockMantle),
  "@ai-sdk/anthropic": () => import("@ai-sdk/anthropic").then((m) => m.createAnthropic),
  "@ai-sdk/azure": () => import("@ai-sdk/azure").then((m) => m.createAzure),
  "@ai-sdk/google": () => import("@ai-sdk/google").then((m) => m.createGoogleGenerativeAI),
-  "@ai-sdk/google-vertex": () => import("@ai-sdk/google-vertex").then((m) => m.createVertex),
-  "@ai-sdk/google-vertex/anthropic": () =>
-    import("@ai-sdk/google-vertex/anthropic").then((m) => m.createVertexAnthropic),
  "@ai-sdk/openai": () => import("@ai-sdk/openai").then((m) => m.createOpenAI),
  "@ai-sdk/openai-compatible": () => import("@ai-sdk/openai-compatible").then((m) => m.createOpenAICompatible),
  "@openrouter/ai-sdk-provider": () => import("@openrouter/ai-sdk-provider").then((m) => m.createOpenRouter),
@@ -267,178 +262,6 @@ function custom(dep: CustomDep): Record<string, CustomLoader> {
        },
      }
    }),
-    "azure-cognitive-services": Effect.fnUntraced(function* (provider: Info) {
-      const resourceName = yield* dep.get("AZURE_COGNITIVE_SERVICES_RESOURCE_NAME")
-      return {
-        autoload: false,
-        async getModel(sdk: any, modelID: string, options?: Record<string, any>) {
-          return selectAzureLanguageModel(sdk, modelID, Boolean(options?.["useCompletionUrls"]))
-        },
-        options: {
-          baseURL: resourceName
-            ? `https://${resourceName}.cognitiveservices.azure.com/openai${provider.options?.useDeploymentBasedUrls ? "" : "/v1"}`
-            : undefined,
-        },
-      }
-    }),
-    "amazon-bedrock": Effect.fnUntraced(function* () {
-      const providerConfig = (yield* dep.config()).provider?.["amazon-bedrock"]
-      const auth = yield* dep.auth("amazon-bedrock")
-      const env = yield* dep.env()
-
-      // Region precedence: 1) config file, 2) env var, 3) default
-      const configRegion = providerConfig?.options?.region
-      const envRegion = env["AWS_REGION"]
-      const defaultRegion = configRegion ?? envRegion ?? "us-east-1"
-
-      // Profile: config file takes precedence over env var
-      const configProfile = providerConfig?.options?.profile
-      const envProfile = env["AWS_PROFILE"]
-      const profile = configProfile ?? envProfile
-
-      const awsAccessKeyId = env["AWS_ACCESS_KEY_ID"]
-      const configApiKey = providerConfig?.options?.apiKey
-
-      // the AWS SDK reads this from process.env lazily at request time, so go
-      // through Env.set which writes through to process.env
-      let awsBearerToken = process.env.AWS_BEARER_TOKEN_BEDROCK
-      if (!awsBearerToken && auth?.type === "api") {
-        yield* dep.set("AWS_BEARER_TOKEN_BEDROCK", auth.key)
-        awsBearerToken = auth.key
-      }
-
-      const awsWebIdentityTokenFile = env["AWS_WEB_IDENTITY_TOKEN_FILE"]
-
-      const containerCreds = Boolean(
-        process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI || process.env.AWS_CONTAINER_CREDENTIALS_FULL_URI,
-      )
-
-      if (
-        !profile &&
-        !awsAccessKeyId &&
-        !awsBearerToken &&
-        !configApiKey &&
-        !awsWebIdentityTokenFile &&
-        !containerCreds
-      )
-        return { autoload: false }
-
-      const { fromNodeProviderChain } = yield* Effect.promise(() => import("@aws-sdk/credential-providers"))
-
-      const providerOptions: Record<string, any> = {
-        region: defaultRegion,
-      }
-
-      // Only use credential chain if no bearer token exists
-      // Bearer token takes precedence over credential chain (profiles, access keys, IAM roles, web identity tokens)
-      if (!awsBearerToken && !configApiKey) {
-        // Build credential provider options (only pass profile if specified)
-        const credentialProviderOptions = profile ? { profile } : {}
-
-        providerOptions.credentialProvider = fromNodeProviderChain(credentialProviderOptions)
-      }
-
-      // Add custom endpoint if specified (endpoint takes precedence over baseURL)
-      const endpoint = providerConfig?.options?.endpoint ?? providerConfig?.options?.baseURL
-      if (endpoint) {
-        providerOptions.baseURL = endpoint
-      }
-
-      return {
-        autoload: true,
-        options: providerOptions,
-        vars(options: Record<string, any>) {
-          return { AWS_REGION: options.region ?? defaultRegion }
-        },
-        async getModel(sdk: any, modelID: string, options?: Record<string, any>, model?: Model) {
-          if (model?.api.npm === "@ai-sdk/amazon-bedrock/mantle") return selectBedrockMantleLanguageModel(sdk, modelID)
-
-          // Skip region prefixing if model already has a cross-region inference profile prefix
-          // Models from models.dev may already include prefixes like us., eu., global., etc.
-          const crossRegionPrefixes = ["global.", "us.", "eu.", "jp.", "apac.", "au."]
-          if (crossRegionPrefixes.some((prefix) => modelID.startsWith(prefix))) {
-            return sdk.languageModel(modelID)
-          }
-
-          // Region resolution precedence (highest to lowest):
-          // 1. options.region from opencode.json provider config
-          // 2. defaultRegion from AWS_REGION environment variable
-          // 3. Default "us-east-1" (baked into defaultRegion)
-          const region = options?.region ?? defaultRegion
-
-          let regionPrefix = region.split("-")[0]
-
-          switch (regionPrefix) {
-            case "us": {
-              const modelRequiresPrefix = [
-                "nova-micro",
-                "nova-lite",
-                "nova-pro",
-                "nova-premier",
-                "nova-2",
-                "claude",
-                "deepseek",
-              ].some((m) => modelID.includes(m))
-              const isGovCloud = region.startsWith("us-gov")
-              if (modelRequiresPrefix && !isGovCloud) {
-                modelID = `${regionPrefix}.${modelID}`
-              }
-              break
-            }
-            case "eu": {
-              const regionRequiresPrefix = [
-                "eu-west-1",
-                "eu-west-2",
-                "eu-west-3",
-                "eu-north-1",
-                "eu-central-1",
-                "eu-south-1",
-                "eu-south-2",
-              ].some((r) => region.includes(r))
-              const modelRequiresPrefix = ["claude", "nova-lite", "nova-micro", "llama3", "pixtral"].some((m) =>
-                modelID.includes(m),
-              )
-              if (regionRequiresPrefix && modelRequiresPrefix) {
-                modelID = `${regionPrefix}.${modelID}`
-              }
-              break
-            }
-            case "ap": {
-              const isAustraliaRegion = ["ap-southeast-2", "ap-southeast-4"].includes(region)
-              const isTokyoRegion = region === "ap-northeast-1"
-              if (
-                isAustraliaRegion &&
-                ["anthropic.claude-sonnet-4-5", "anthropic.claude-haiku"].some((m) => modelID.includes(m))
-              ) {
-                regionPrefix = "au"
-                modelID = `${regionPrefix}.${modelID}`
-              } else if (isTokyoRegion) {
-                // Tokyo region uses jp. prefix for cross-region inference
-                const modelRequiresPrefix = ["claude", "nova-lite", "nova-micro", "nova-pro"].some((m) =>
-                  modelID.includes(m),
-                )
-                if (modelRequiresPrefix) {
-                  regionPrefix = "jp"
-                  modelID = `${regionPrefix}.${modelID}`
-                }
-              } else {
-                // Other APAC regions use apac. prefix
-                const modelRequiresPrefix = ["claude", "nova-lite", "nova-micro", "nova-pro"].some((m) =>
-                  modelID.includes(m),
-                )
-                if (modelRequiresPrefix) {
-                  regionPrefix = "apac"
-                  modelID = `${regionPrefix}.${modelID}`
-                }
-              }
-              break
-            }
-          }
-
-          return sdk.languageModel(modelID)
-        },
-      }
-    }),
    llmgateway: () =>
      Effect.succeed({
        autoload: false,
@@ -467,7 +290,7 @@ function custom(dep: CustomDep): Record<string, CustomLoader> {
          headers: {
            "HTTP-Referer": "https://opencode.ai/",
            "X-Title": "opencode",
-            "X-BILLING-INVOKE-ORIGIN": "OpenCode",
+            "X-BILLING-INVOKE-ORIGIN": "Neuron",
          },
        },
      }),
@@ -481,97 +304,6 @@ function custom(dep: CustomDep): Record<string, CustomLoader> {
          },
        },
      }),
-    "google-vertex": Effect.fnUntraced(function* (provider: Info) {
-      const env = yield* dep.env()
-      // models.dev advertises GOOGLE_VERTEX_PROJECT for Vertex; keep the wider
-      // Google Cloud project env names as fallbacks for existing ADC setups.
-      const project =
-        provider.options?.project ??
-        env["GOOGLE_VERTEX_PROJECT"] ??
-        env["GOOGLE_CLOUD_PROJECT"] ??
-        env["GCP_PROJECT"] ??
-        env["GCLOUD_PROJECT"]
-
-      const location = String(
-        provider.options?.location ??
-          env["GOOGLE_VERTEX_LOCATION"] ??
-          env["GOOGLE_CLOUD_LOCATION"] ??
-          env["VERTEX_LOCATION"] ??
-          "us-central1",
-      )
-
-      const autoload = Boolean(project)
-      if (!autoload) return { autoload: false }
-      return {
-        autoload: true,
-        vars(_options: Record<string, any>) {
-          return {
-            ...(project && { GOOGLE_VERTEX_PROJECT: project }),
-            GOOGLE_VERTEX_LOCATION: location,
-            GOOGLE_VERTEX_ENDPOINT: googleVertexEndpoint(location),
-          }
-        },
-        options: {
-          project,
-          location,
-          fetch: async (input: RequestInfo | URL, init?: RequestInit) => {
-            const { GoogleAuth } = await import("google-auth-library")
-            const auth = new GoogleAuth({ scopes: ["https://www.googleapis.com/auth/cloud-platform"] })
-            const client = await auth.getClient()
-            const token = await client.getAccessToken()
-
-            const headers = new Headers(init?.headers)
-            headers.set("Authorization", `Bearer ${token.token}`)
-
-            return fetch(input, { ...init, headers })
-          },
-        },
-        async getModel(sdk: any, modelID: string) {
-          const id = String(modelID).trim()
-          return sdk.languageModel(id)
-        },
-      }
-    }),
-    "google-vertex-anthropic": Effect.fnUntraced(function* () {
-      const env = yield* dep.env()
-      const project = env["GOOGLE_CLOUD_PROJECT"] ?? env["GCP_PROJECT"] ?? env["GCLOUD_PROJECT"]
-      const location = env["GOOGLE_CLOUD_LOCATION"] ?? env["VERTEX_LOCATION"] ?? "global"
-      const autoload = Boolean(project)
-      if (!autoload) return { autoload: false }
-      const baseURL = googleVertexAnthropicBaseURL(project, location)
-      return {
-        autoload: true,
-        options: {
-          project,
-          location,
-          ...(baseURL && { baseURL }),
-        },
-        async getModel(sdk: any, modelID) {
-          const id = String(modelID).trim()
-          return sdk.languageModel(id)
-        },
-      }
-    }),
-    "sap-ai-core": Effect.fnUntraced(function* () {
-      const auth = yield* dep.auth("sap-ai-core")
-      // the SAP SDK reads this from process.env lazily at request time, so go
-      // through Env.set which writes through to process.env
-      let envServiceKey = process.env.AICORE_SERVICE_KEY
-      if (!envServiceKey && auth?.type === "api") {
-        yield* dep.set("AICORE_SERVICE_KEY", auth.key)
-        envServiceKey = auth.key
-      }
-      const deploymentId = process.env.AICORE_DEPLOYMENT_ID
-      const resourceGroup = process.env.AICORE_RESOURCE_GROUP
-
-      return {
-        autoload: !!envServiceKey,
-        options: envServiceKey ? { deploymentId, resourceGroup } : {},
-        async getModel(sdk: any, modelID: string) {
-          return sdk(modelID)
-        },
-      }
-    }),
    zenmux: () =>
      Effect.succeed({
        autoload: false,
@@ -707,132 +439,6 @@ function custom(dep: CustomDep): Record<string, CustomLoader> {
        },
      }
    }),
-    "cloudflare-workers-ai": Effect.fnUntraced(function* (input: Info) {
-      // When baseURL is already configured (e.g. corporate config routing through a proxy/gateway),
-      // skip the account ID check because the URL is already fully specified.
-      if (input.options?.baseURL) return { autoload: false }
-
-      const auth = yield* dep.auth(input.id)
-      const env = yield* dep.env()
-      const accountId = env["CLOUDFLARE_ACCOUNT_ID"] || (auth?.type === "api" ? auth.metadata?.accountId : undefined)
-      if (!accountId)
-        return {
-          autoload: false,
-          async getModel() {
-            throw new Error(
-              "CLOUDFLARE_ACCOUNT_ID is missing. Set it with: export CLOUDFLARE_ACCOUNT_ID=<your-account-id>",
-            )
-          },
-        }
-
-      const apiKey = env["CLOUDFLARE_API_KEY"] || (auth?.type === "api" ? auth.key : undefined)
-
-      return {
-        autoload: !!apiKey,
-        options: {
-          apiKey,
-          headers: {
-            "User-Agent": `opencode/${InstallationVersion} cloudflare-workers-ai (${os.platform()} ${os.release()}; ${os.arch()})`,
-          },
-        },
-        async getModel(sdk: any, modelID: string) {
-          return sdk.languageModel(modelID)
-        },
-        vars(_options) {
-          return {
-            CLOUDFLARE_ACCOUNT_ID: accountId,
-          }
-        },
-      }
-    }),
-    "cloudflare-ai-gateway": Effect.fnUntraced(function* (input: Info) {
-      // When baseURL is already configured (e.g. corporate config), skip the ID checks.
-      if (input.options?.baseURL) return { autoload: false }
-
-      const auth = yield* dep.auth(input.id)
-      const env = yield* dep.env()
-      const accountId = env["CLOUDFLARE_ACCOUNT_ID"] || (auth?.type === "api" ? auth.metadata?.accountId : undefined)
-      // The Cloudflare auth prompt stores this value as gatewayId metadata.
-      const gateway = env["CLOUDFLARE_GATEWAY_ID"] || (auth?.type === "api" ? auth.metadata?.gatewayId : undefined)
-
-      if (!accountId || !gateway) {
-        const missing = [
-          !accountId ? "CLOUDFLARE_ACCOUNT_ID" : undefined,
-          !gateway ? "CLOUDFLARE_GATEWAY_ID" : undefined,
-        ].filter((x): x is string => Boolean(x))
-        return {
-          autoload: false,
-          async getModel() {
-            throw new Error(
-              `${missing.join(" and ")} missing. Set with: ${missing.map((x) => `export ${x}=<value>`).join(" && ")}`,
-            )
-          },
-        }
-      }
-
-      // Get API token from env or auth - required for authenticated gateways
-      const apiToken =
-        env["CLOUDFLARE_API_TOKEN"] || env["CF_AIG_TOKEN"] || (auth?.type === "api" ? auth.key : undefined)
-
-      if (!apiToken) {
-        throw new Error(
-          "CLOUDFLARE_API_TOKEN (or CF_AIG_TOKEN) is required for Cloudflare AI Gateway. " +
-            "Set it via environment variable or run `opencode auth cloudflare-ai-gateway`.",
-        )
-      }
-
-      const { createAiGateway } = yield* Effect.promise(() => import("ai-gateway-provider"))
-      const { createUnified } = yield* Effect.promise(() => import("ai-gateway-provider/providers/unified"))
-      const { createOpenAI } = yield* Effect.promise(() => import("ai-gateway-provider/providers/openai"))
-      const { createAnthropic } = yield* Effect.promise(() => import("ai-gateway-provider/providers/anthropic"))
-
-      const metadata = iife(() => {
-        if (input.options?.metadata) return input.options.metadata
-        try {
-          return JSON.parse(input.options?.headers?.["cf-aig-metadata"])
-        } catch {
-          return undefined
-        }
-      })
-      const opts = {
-        metadata,
-        cacheTtl: input.options?.cacheTtl,
-        cacheKey: input.options?.cacheKey,
-        skipCache: input.options?.skipCache,
-        collectLog: input.options?.collectLog,
-        headers: {
-          "User-Agent": `opencode/${InstallationVersion} cloudflare-ai-gateway (${os.platform()} ${os.release()}; ${os.arch()})`,
-        },
-      }
-
-      const aigateway = createAiGateway({
-        accountId,
-        gateway,
-        apiKey: apiToken,
-        ...(Object.values(opts).some((v) => v !== undefined) ? { options: opts } : {}),
-      })
-      return {
-        autoload: true,
-        async getModel(_sdk: any, modelID: string, _options?: Record<string, any>) {
-          // Model IDs use Unified API format: provider/model (e.g., "anthropic/claude-sonnet-4-5").
-          // OpenAI and Anthropic ride their native passthrough routes so agents get the Responses
-          // and Messages APIs; new OpenAI models reject tools+reasoning_effort on chat completions.
-          // The passthrough wrappers inject a CF_TEMP_TOKEN sentinel that the gateway strips before
-          // dispatch, so upstream billing stays on the gateway (Unified Billing / stored BYOK).
-          if (modelID.startsWith("openai/")) return aigateway(createOpenAI()(modelID.slice("openai/".length)))
-          if (modelID.startsWith("anthropic/")) return aigateway(createAnthropic()(modelID.slice("anthropic/".length)))
-          // Workers AI is the only first-party provider whose upstream is Cloudflare itself, so it is
-          // the only one that should receive the Cloudflare token as its upstream Authorization header.
-          // The Unified API addresses Workers AI both with the explicit "workers-ai/" prefix and as
-          // bare "@cf/..." ids. Third-party providers must not receive the token; they rely on the
-          // gateway's stored/BYOK keys instead.
-          const isWorkersAi = modelID.startsWith("workers-ai/") || modelID.startsWith("@cf/")
-          const unified = createUnified(isWorkersAi ? { apiKey: apiToken } : {})
-          return aigateway(unified(modelID))
-        },
-        options: {},
-      }
-    }),
    cerebras: () =>
      Effect.succeed({
        autoload: false,
@@ -852,106 +458,6 @@ function custom(dep: CustomDep): Record<string, CustomLoader> {
          },
        },
      }),
-    "snowflake-cortex": Effect.fnUntraced(function* (input: Info) {
-      const env = yield* dep.env()
-      const auth = yield* dep.auth(input.id)
-
-      const account =
-        env["SNOWFLAKE_ACCOUNT"] ??
-        (auth?.type === "api" ? auth.metadata?.account : undefined) ??
-        (auth?.type === "oauth" ? auth.accountId : undefined) ??
-        input.options?.account
-
-      const envToken = env["SNOWFLAKE_CORTEX_TOKEN"] ?? env["SNOWFLAKE_CORTEX_PAT"]
-      const apiKeyToken = auth?.type === "api" ? auth.key : undefined
-      const oauthToken = auth?.type === "oauth" ? auth.access : undefined
-      const configToken = input.options?.token ?? input.options?.apiKey
-
-      const token = envToken ?? apiKeyToken ?? oauthToken ?? configToken
-
-      if (!account || !token) {
-        const missing = [!account && "SNOWFLAKE_ACCOUNT", !token && "SNOWFLAKE_CORTEX_TOKEN"].filter(Boolean).join(", ")
-        return {
-          autoload: false,
-          async getModel() {
-            throw new Error(
-              `Snowflake Cortex: missing credentials (${missing}). Provide a bearer token (OAuth, JWT, or PAT) via env var, opencode auth, or provider options.`,
-            )
-          },
-        }
-      }
-
-      const baseURL = `https://${account}.snowflakecomputing.com/api/v2/cortex/v1`
-
-      const options: Record<string, any> = { baseURL, apiKey: token }
-
-      // Only skip provider-level fetch when the token is from OAuth with no override.
-      // For OAuth tokens, the plugin auth loader's combined fetch handles
-      // OAuth refresh + snowflake transformations in one place.
-      // For env/config/API-key tokens, the provider fetch applies snowflake
-      // transformations directly.
-      const useOAuthHandler =
-        oauthToken !== undefined && envToken === undefined && apiKeyToken === undefined && configToken === undefined
-      if (!useOAuthHandler) {
-        options.fetch = async (url: RequestInfo | URL, init?: RequestInit) => {
-          if (init?.body && typeof init.body === "string") {
-            try {
-              const body = JSON.parse(init.body)
-              if ("max_tokens" in body) {
-                body.max_completion_tokens = body.max_tokens
-                delete body.max_tokens
-                init = { ...init, body: JSON.stringify(body) }
-              }
-            } catch {}
-          }
-
-          const response = await fetch(url, init)
-
-          if (!response.ok && response.status === 400) {
-            try {
-              const errorData = await response.clone().json()
-              const errorMessage = String(errorData.message || errorData.error || "")
-              if (errorMessage.toLowerCase().includes("conversation complete")) {
-                return new Response(
-                  JSON.stringify({
-                    choices: [{ finish_reason: "stop", message: { content: "", role: "assistant" } }],
-                  }),
-                  { status: 200, headers: new Headers({ "content-type": "application/json" }) },
-                )
-              }
-            } catch {}
-          }
-
-          if (response.body && response.headers.get("content-type")?.includes("text/event-stream")) {
-            const reader = response.body.getReader()
-            const encoder = new TextEncoder()
-            const decoder = new TextDecoder()
-            const stream = new ReadableStream({
-              async pull(ctrl) {
-                const { done, value } = await reader.read()
-                if (done) {
-                  ctrl.close()
-                  return
-                }
-                const text = decoder.decode(value, { stream: true })
-                ctrl.enqueue(encoder.encode(text.replace(/"role"\s*:\s*""/g, '"role":"assistant"')))
-              },
-              cancel() {
-                reader.cancel()
-              },
-            })
-            return new Response(stream, { headers: response.headers, status: response.status })
-          }
-
-          return response
-        }
-      }
-
-      return {
-        autoload: input.source === "config",
-        options,
-      }
-    }),
  }
 }

@@ -1496,7 +1496,7 @@ export function schema(model: Provider.Model, schema: JSONSchema7): JSONSchema7

  if (model.api.npm === "@ai-sdk/openai" || model.api.npm === "@ai-sdk/azure") {
    schema = sanitizeOpenAISchema(schema) as JSONSchema7
-    // Codex also applies lossy compaction above 4 KB; defer that until OpenCode needs the same schema budget.
+    // Codex also applies lossy compaction above 4 KB; defer that until Neuron needs the same schema budget.
  }

  if (model.providerID === "moonshotai" || model.api.id.toLowerCase().includes("kimi")) {
@@ -9,7 +9,6 @@ import { InstanceDisposed } from "@/server/event"
 import { Question } from "@/question"
 import { ConfigApi } from "./groups/config"
 import { ControlApi } from "./groups/control"
-import { ControlPlaneApi } from "./groups/control-plane"
 import { EventApi } from "./groups/event"
 import { ExperimentalApi } from "./groups/experimental"
 import { FileApi } from "./groups/file"
@@ -53,7 +52,6 @@ export const ServerApi = makeApi({

 export const RootHttpApi = HttpApi.make("opencode-root")
  .addHttpApi(ControlApi)
-  .addHttpApi(ControlPlaneApi)
  .addHttpApi(GlobalApi)
  .middleware(SchemaErrorMiddleware)
  .middleware(Authorization)
@@ -20,7 +20,7 @@ export const ConfigApi = HttpApi.make("config")
          OpenApi.annotations({
            identifier: "config.get",
            summary: "Get configuration",
-            description: "Retrieve the current OpenCode configuration settings and preferences.",
+            description: "Retrieve the current Neuron configuration settings and preferences.",
          }),
        ),
        HttpApiEndpoint.patch("update", root, {
@@ -32,7 +32,7 @@ export const ConfigApi = HttpApi.make("config")
          OpenApi.annotations({
            identifier: "config.update",
            summary: "Update configuration",
-            description: "Update OpenCode configuration settings and preferences.",
+            description: "Update Neuron configuration settings and preferences.",
          }),
        ),
        HttpApiEndpoint.get("providers", `${root}/providers`, {
@@ -1,35 +0,0 @@
-import { MoveSession } from "@opencode-ai/core/control-plane/move-session"
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { described } from "./metadata"
-
-const root = "/experimental/control-plane"
-export const MoveSessionPayload = Schema.Struct({ ...MoveSession.Input.fields })
-
-export class ApiMoveSessionError extends Schema.ErrorClass<ApiMoveSessionError>("MoveSessionError")(
-  {
-    name: Schema.Literal("MoveSessionError"),
-    data: Schema.Struct({
-      message: Schema.String,
-    }),
-  },
-  { httpApiStatus: 400 },
-) {}
-
-export const ControlPlaneApi = HttpApi.make("controlPlane").add(
-  HttpApiGroup.make("controlPlane")
-    .add(
-      HttpApiEndpoint.post("moveSession", `${root}/move-session`, {
-        payload: MoveSessionPayload,
-        success: described(HttpApiSchema.NoContent, "Session moved"),
-        error: ApiMoveSessionError,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "experimental.controlPlane.moveSession",
-          summary: "Move session",
-          description: "Move a session to another project directory, optionally transferring local changes.",
-        }),
-      ),
-    )
-    .annotateMerge(OpenApi.annotations({ title: "controlPlane", description: "Control-plane orchestration routes." })),
-)
@@ -112,7 +112,7 @@ export const ExperimentalApi = HttpApi.make("experimental")
          OpenApi.annotations({
            identifier: "experimental.capabilities.get",
            summary: "Get experimental capabilities",
-            description: "Get experimental features enabled on the OpenCode server.",
+            description: "Get experimental features enabled on the Neuron server.",
          }),
        ),
        HttpApiEndpoint.get("console", ExperimentalPaths.console, {
@@ -146,7 +146,7 @@ export const ExperimentalApi = HttpApi.make("experimental")
          OpenApi.annotations({
            identifier: "experimental.console.switchOrg",
            summary: "Switch active Console org",
-            description: "Persist a new active Console account/org selection for the current local OpenCode state.",
+            description: "Persist a new active Console account/org selection for the current local Neuron state.",
          }),
        ),
        HttpApiEndpoint.get("tool", ExperimentalPaths.tool, {
@@ -229,7 +229,7 @@ export const ExperimentalApi = HttpApi.make("experimental")
            identifier: "experimental.session.list",
            summary: "List sessions",
            description:
-              "Get a list of all OpenCode sessions across projects, sorted by most recently updated. Archived sessions are excluded by default.",
+              "Get a list of all Neuron sessions across projects, sorted by most recently updated. Archived sessions are excluded by default.",
          }),
        ),
        HttpApiEndpoint.post("sessionBackground", ExperimentalPaths.sessionBackground, {
@@ -79,7 +79,7 @@ export const GlobalApi = HttpApi.make("global").add(
        OpenApi.annotations({
          identifier: "global.health",
          summary: "Get health",
-          description: "Get health information about the OpenCode server.",
+          description: "Get health information about the Neuron server.",
        }),
      ),
      HttpApiEndpoint.get("event", GlobalPaths.event, {
@@ -88,7 +88,7 @@ export const GlobalApi = HttpApi.make("global").add(
        OpenApi.annotations({
          identifier: "global.event",
          summary: "Get global events",
-          description: "Subscribe to global events from the OpenCode system using server-sent events.",
+          description: "Subscribe to global events from the Neuron system using server-sent events.",
        }),
      ),
      HttpApiEndpoint.get("configGet", GlobalPaths.config, {
@@ -97,7 +97,7 @@ export const GlobalApi = HttpApi.make("global").add(
        OpenApi.annotations({
          identifier: "global.config.get",
          summary: "Get global configuration",
-          description: "Retrieve the current global OpenCode configuration settings and preferences.",
+          description: "Retrieve the current global Neuron configuration settings and preferences.",
        }),
      ),
      HttpApiEndpoint.patch("configUpdate", GlobalPaths.config, {
@@ -108,7 +108,7 @@ export const GlobalApi = HttpApi.make("global").add(
        OpenApi.annotations({
          identifier: "global.config.update",
          summary: "Update global configuration",
-          description: "Update global OpenCode configuration settings and preferences.",
+          description: "Update global Neuron configuration settings and preferences.",
        }),
      ),
      HttpApiEndpoint.post("dispose", GlobalPaths.dispose, {
@@ -117,7 +117,7 @@ export const GlobalApi = HttpApi.make("global").add(
        OpenApi.annotations({
          identifier: "global.dispose",
          summary: "Dispose instance",
-          description: "Clean up and dispose all OpenCode instances, releasing all resources.",
+          description: "Clean up and dispose all Neuron instances, releasing all resources.",
        }),
      ),
      HttpApiEndpoint.post("upgrade", GlobalPaths.upgrade, {
@@ -66,7 +66,7 @@ export const InstanceApi = HttpApi.make("instance")
          OpenApi.annotations({
            identifier: "instance.dispose",
            summary: "Dispose instance",
-            description: "Clean up and dispose the current OpenCode instance, releasing all resources.",
+            description: "Clean up and dispose the current Neuron instance, releasing all resources.",
          }),
        ),
        HttpApiEndpoint.get("path", InstancePaths.path, {
@@ -77,7 +77,7 @@ export const InstanceApi = HttpApi.make("instance")
            identifier: "path.get",
            summary: "Get paths",
            description:
-              "Retrieve the current working directory and related path information for the OpenCode instance.",
+              "Retrieve the current working directory and related path information for the Neuron instance.",
          }),
        ),
        HttpApiEndpoint.get("vcs", InstancePaths.vcs, {
@@ -143,7 +143,7 @@ export const InstanceApi = HttpApi.make("instance")
          OpenApi.annotations({
            identifier: "command.list",
            summary: "List commands",
-            description: "Get a list of all available commands in the OpenCode system.",
+            description: "Get a list of all available commands in the Neuron system.",
          }),
        ),
        HttpApiEndpoint.get("agent", InstancePaths.agent, {
@@ -153,7 +153,7 @@ export const InstanceApi = HttpApi.make("instance")
          OpenApi.annotations({
            identifier: "app.agents",
            summary: "List agents",
-            description: "Get a list of all available AI agents in the OpenCode system.",
+            description: "Get a list of all available AI agents in the Neuron system.",
          }),
        ),
        HttpApiEndpoint.get("skill", InstancePaths.skill, {
@@ -163,7 +163,7 @@ export const InstanceApi = HttpApi.make("instance")
          OpenApi.annotations({
            identifier: "app.skills",
            summary: "List skills",
-            description: "Get a list of all available skills in the OpenCode system.",
+            description: "Get a list of all available skills in the Neuron system.",
          }),
        ),
        HttpApiEndpoint.get("lsp", InstancePaths.lsp, {
@@ -26,7 +26,7 @@ export const ProjectApi = HttpApi.make("project")
          OpenApi.annotations({
            identifier: "project.list",
            summary: "List all projects",
-            description: "Get a list of projects that have been opened with OpenCode.",
+            description: "Get a list of projects that have been opened with Neuron.",
          }),
        ),
        HttpApiEndpoint.get("current", `${root}/current`, {
@@ -36,7 +36,7 @@ export const ProjectApi = HttpApi.make("project")
          OpenApi.annotations({
            identifier: "project.current",
            summary: "Get current project",
-            description: "Retrieve the currently active project that OpenCode is working with.",
+            description: "Retrieve the currently active project that Neuron is working with.",
          }),
        ),
        HttpApiEndpoint.post("initGit", `${root}/git/init`, {
@@ -58,7 +58,7 @@ export const PtyApi = HttpApi.make("pty")
          OpenApi.annotations({
            identifier: "pty.list",
            summary: "List PTY sessions",
-            description: "Get a list of all active pseudo-terminal (PTY) sessions managed by OpenCode.",
+            description: "Get a list of all active pseudo-terminal (PTY) sessions managed by Neuron.",
          }),
        ),
        HttpApiEndpoint.post("create", PtyPaths.create, {
@@ -115,7 +115,7 @@ export const SessionApi = HttpApi.make("session")
          OpenApi.annotations({
            identifier: "session.list",
            summary: "List sessions",
-            description: "Get a list of all OpenCode sessions, sorted by most recently updated.",
+            description: "Get a list of all Neuron sessions, sorted by most recently updated.",
          }),
        ),
        HttpApiEndpoint.get("status", SessionPaths.status, {
@@ -138,7 +138,7 @@ export const SessionApi = HttpApi.make("session")
          OpenApi.annotations({
            identifier: "session.get",
            summary: "Get session",
-            description: "Retrieve detailed information about a specific OpenCode session.",
+            description: "Retrieve detailed information about a specific Neuron session.",
          }),
        ),
        HttpApiEndpoint.get("children", SessionPaths.children, {
@@ -209,7 +209,7 @@ export const SessionApi = HttpApi.make("session")
          OpenApi.annotations({
            identifier: "session.create",
            summary: "Create session",
-            description: "Create a new OpenCode session for interacting with AI assistants and managing conversations.",
+            description: "Create a new Neuron session for interacting with AI assistants and managing conversations.",
          }),
        ),
        HttpApiEndpoint.delete("remove", SessionPaths.remove, {
@@ -1,37 +0,0 @@
-import { MoveSession } from "@opencode-ai/core/control-plane/move-session"
-import { SessionV2 } from "@opencode-ai/core/session"
-import { Effect } from "effect"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { RootHttpApi } from "../api"
-import { ApiMoveSessionError, MoveSessionPayload } from "../groups/control-plane"
-
-export const controlPlaneHandlers = HttpApiBuilder.group(RootHttpApi, "controlPlane", (handlers) =>
-  Effect.gen(function* () {
-    const service = yield* MoveSession.Service
-
-    const moveSession = Effect.fn("ControlPlaneHttpApi.moveSession")(function* (ctx: {
-      payload: typeof MoveSessionPayload.Type
-    }) {
-      yield* service.moveSession(ctx.payload).pipe(
-        Effect.mapError(
-          (error) =>
-            new ApiMoveSessionError({
-              name: "MoveSessionError",
-              data: { message: message(error) },
-            }),
-        ),
-      )
-    })
-
-    return handlers.handle("moveSession", moveSession)
-  }),
-)
-
-function message(error: MoveSession.Error) {
-  if (error instanceof SessionV2.NotFoundError) return `Session not found: ${error.sessionID}`
-  if (error instanceof MoveSession.DestinationProjectMismatchError)
-    return "Destination directory belongs to another project"
-  if (error instanceof MoveSession.ApplyChangesError)
-    return `Unable to apply your changes in the destination directory. The files may conflict with existing changes.`
-  return error.message
-}
@@ -49,7 +49,6 @@ import { ToolRegistry } from "@/tool/registry"
 import { Truncate } from "@/tool/truncate"
 import { Worktree } from "@/worktree"
 import { RuntimeFlags } from "@/effect/runtime-flags"
-import { MoveSession } from "@opencode-ai/core/control-plane/move-session"
 import { Database } from "@opencode-ai/core/database/database"
 import { AppNodeBuilderV1 } from "@/effect/app-node-builder-v1"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
@@ -84,7 +83,6 @@ import { PtyConnectApi } from "./groups/pty"
 import { eventHandlers } from "./handlers/event"
 import { configHandlers } from "./handlers/config"
 import { controlHandlers } from "./handlers/control"
-import { controlPlaneHandlers } from "./handlers/control-plane"
 import { experimentalHandlers } from "./handlers/experimental"
 import { fileHandlers } from "./handlers/file"
 import { globalHandlers } from "./handlers/global"
@@ -139,7 +137,7 @@ const ptyConnectHttpApiAuthLayer = ptyConnectAuthorizationLayer.pipe(Layer.provi
 const serverHttpApiAuthLayer = serverAuthorizationLayer.pipe(Layer.provide(ServerAuth.Config.layer))
 const workspaceRoutingLive = workspaceRoutingLayer.pipe(Layer.provide(Socket.layerWebSocketConstructorGlobal))
 const rootApiRoutes = HttpApiBuilder.layer(RootHttpApi).pipe(
-  Layer.provide([controlHandlers, controlPlaneHandlers, globalHandlers]),
+  Layer.provide([controlHandlers, globalHandlers]),
  Layer.provide(schemaErrorLayer),
  Layer.provide(httpApiAuthLayer),
 )
@@ -288,7 +286,6 @@ export function createRoutes(
      corsVaryFix,
      fenceLayer,
      cors(corsOptions),
-      AppNodeBuilderV1.build(MoveSession.node, [[LocationServiceMap.node, locationServiceMapV2]]),
      HttpServer.layerServices,
    ]),
    Layer.provide(Layer.succeed(CorsConfig)(corsOptions)),
@@ -7,8 +7,8 @@ import { isRecord } from "@/util/record"

 export type Err = ReturnType<NamedError["toObject"]>

-export const GO_UPSELL_MESSAGE = "Free usage exceeded, subscribe to Go"
-export const GO_UPSELL_URL = "https://opencode.ai/go"
+export const GO_UPSELL_MESSAGE = "Free usage exceeded on the managed provider"
+export const GO_UPSELL_URL = "https://git.neuralplatform.ai/neuron-technologies/neuron"
 export type RetryReason = "free_tier_limit" | "account_rate_limit" | (string & {})

 export type Retryable = {
@@ -103,7 +103,7 @@ export function retryable(error: Err, provider: string) {
          reason: "free_tier_limit",
          provider,
          title: "Free limit reached",
-          message: "Subscribe to OpenCode Go for reliable access to the best open-source models, starting at $5/month.",
+          message: "Free limit reached on the managed provider. Configure your own provider API key for unlimited use.",
          label: "subscribe",
          link: GO_UPSELL_URL,
        },