feat: add Maple AI provider integration

Add Maple AI as a first-class provider with dynamic model discovery.

- Provider dynamically fetches models from running Maple proxy
- Supports API key authentication (stored in auth.json)
- Configurable baseURL (default: http://127.0.0.1:8080/v1)
- Helpful setup instructions in both CLI and TUI
- Placed in 'Other' category without special hints
- Gracefully handles proxy unavailability (no models shown)

Users run /connect to add their Maple API key, then /models to see
available models fetched directly from their Maple proxy.

Author: marksftw

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

@@ -317,6 +317,15 @@ export const ProvidersLoginCommand = cmd({
               filtered[key] = value
             }
           }
+          // Add Maple AI (not in models.dev, models discovered dynamically from proxy)
+          if ((enabled ? enabled.has("maple") : true) && !disabled.has("maple")) {
+            filtered["maple"] = {
+              id: "maple",
+              name: "Maple AI",
+              env: ["MAPLE_API_KEY"],
+              models: {},
+            }
+          }
           return filtered
         })
 
@@ -436,6 +445,19 @@ export const ProvidersLoginCommand = cmd({
           )
         }
 
+        if (provider === "maple") {
+          prompts.log.info(
+            "Maple AI is a TEE-based private AI provider.\n\n" +
+              "Setup:\n" +
+              "  1. Start the Maple Proxy (desktop app or Docker)\n" +
+              "  2. Generate an API key in the Maple app\n" +
+              "  3. Enter your API key below\n\n" +
+              "The default proxy URL is http://127.0.0.1:8080/v1\n" +
+              "To use a different URL, add to opencode.json:\n" +
+              '  { "provider": { "maple": { "options": { "baseURL": "http://your-url/v1" } } } }',
+          )
+        }
+
         const key = await prompts.password({
           message: "Enter your API key",
           validate: (x) => (x && x.length > 0 ? undefined : "Required"),

packages/opencode/src/cli/cmd/tui/component/dialog-provider.tsx

@@ -259,6 +259,20 @@ function ApiMethod(props: ApiMethodProps) {
               </text>
             </box>
           ),
+          maple: (
+            <box gap={1}>
+              <text fg={theme.textMuted}>
+                Maple AI is a TEE-based private AI provider. Start the Maple Proxy (desktop app or Docker) and generate
+                an API key in the Maple app.
+              </text>
+              <text fg={theme.text}>
+                Default proxy URL: <span style={{ fg: theme.primary }}>http://127.0.0.1:8080/v1</span>
+              </text>
+              <text fg={theme.textMuted}>
+                To use a different URL, add to opencode.json: provider.maple.options.baseURL
+              </text>
+            </box>
+          ),
         }[props.providerID] ?? undefined
       }
       onConfirm={async (value) => {

packages/opencode/src/provider/provider.ts

@@ -737,14 +737,66 @@ export namespace Provider {
         },
       }
     },
-    kilo: async () => {
+    maple: async (input) => {
+      const config = await Config.get()
+      const baseURL = config.provider?.["maple"]?.options?.baseURL ?? "http://127.0.0.1:8080/v1"
+
+      const auth = await Auth.get("maple")
+      const apiKey = auth?.type === "api" ? auth.key : Env.get("MAPLE_API_KEY")
+
+      if (!apiKey) return { autoload: false }
+
+      // Dynamically fetch models from the Maple proxy
+      try {
+        const response = await fetch(`${baseURL}/models`, {
+          headers: { Authorization: `Bearer ${apiKey}` },
+          signal: AbortSignal.timeout(5000),
+        })
+        if (!response.ok) {
+          log.warn("Failed to fetch Maple models", { status: response.status })
+          return { autoload: false }
+        }
+        const data = (await response.json()) as { data?: Array<{ id: string }> }
+        const models = data.data ?? []
+
+        for (const model of models) {
+          input.models[model.id] = {
+            id: model.id,
+            providerID: "maple",
+            name: model.id,
+            api: {
+              id: model.id,
+              url: baseURL,
+              npm: "@ai-sdk/openai-compatible",
+            },
+            status: "active",
+            headers: {},
+            options: {},
+            cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+            limit: { context: 128000, output: 8192 },
+            capabilities: {
+              temperature: true,
+              reasoning: false,
+              attachment: false,
+              toolcall: true,
+              input: { text: true, audio: false, image: false, video: false, pdf: false },
+              output: { text: true, audio: false, image: false, video: false, pdf: false },
+              interleaved: false,
+            },
+            release_date: "",
+            variants: {},
+          }
+        }
+      } catch (e) {
+        log.warn("Failed to connect to Maple proxy", { error: e })
+        return { autoload: false }
+      }
+
       return {
-        autoload: false,
+        autoload: Object.keys(input.models).length > 0,
         options: {
-          headers: {
-            "HTTP-Referer": "https://opencode.ai/",
-            "X-Title": "opencode",
-          },
+          baseURL,
+          apiKey,
         },
       }
     },
@@ -946,6 +998,16 @@ export namespace Provider {
 
     const configProviders = Object.entries(config.provider ?? {})
 
+    // Add Maple AI provider (models are populated dynamically from the proxy)
+    database["maple"] = {
+      id: "maple",
+      name: "Maple AI",
+      source: "custom",
+      env: ["MAPLE_API_KEY"],
+      options: {},
+      models: {},
+    }
+
     function mergeProvider(providerID: ProviderID, provider: Partial<Info>) {
       const existing = providers[providerID]
       if (existing) {

packages/opencode/src/server/routes/provider.ts

@@ -50,6 +50,15 @@ export const ProviderRoutes = lazy(() =>
             filteredProviders[key] = value
           }
         }
+        // Add Maple AI (not in models.dev, models discovered dynamically from proxy)
+        if ((enabled ? enabled.has("maple") : true) && !disabled.has("maple")) {
+          filteredProviders["maple"] = {
+            id: "maple",
+            name: "Maple AI",
+            env: ["MAPLE_API_KEY"],
+            models: {},
+          }
+        }
 
         const connected = await Provider.list()
         const providers = Object.assign(
@@ -58,7 +67,11 @@ export const ProviderRoutes = lazy(() =>
         )
         return c.json({
           all: Object.values(providers),
-          default: mapValues(providers, (item) => Provider.sort(Object.values(item.models))[0].id),
+          default: mapValues(providers, (item) => {
+            const models = Object.values(item.models)
+            if (models.length === 0) return ""
+            return Provider.sort(models)[0].id
+          }),
           connected: Object.keys(connected),
         })
       },