refactor(provider): generalize model discovery loop for all providers

Replace the hardcoded GitLab discovery block with a generic loop over
all discoveryLoaders entries. Refactor Maple to use the existing
discoverModels hook instead of inline fetching.

Author: marksftw

packages/opencode/src/provider/provider.ts

@@ -813,7 +813,7 @@ function custom(dep: CustomDep): Record<string, CustomLoader> {
           },
         },
       }),
-    maple: Effect.fnUntraced(function* (input: Info) {
+    maple: Effect.fnUntraced(function* () {
       const cfg = yield* dep.config()
       const env = yield* dep.env()
       const baseURL = cfg.provider?.["maple"]?.options?.baseURL ?? "http://127.0.0.1:8080/v1"
@@ -823,59 +823,49 @@ function custom(dep: CustomDep): Record<string, CustomLoader> {
 
       if (!apiKey) return { autoload: false }
 
-      const models = yield* Effect.tryPromise({
-        try: async () => {
+      return {
+        autoload: true,
+        options: {
+          baseURL,
+          apiKey,
+        },
+        async discoverModels(): Promise<Record<string, Model>> {
           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 []
+          if (!response.ok) return {}
+          const data = (await response.json()) as { data?: Array<{ id: string }> }
+          const models: Record<string, Model> = {}
+          for (const m of data.data ?? []) {
+            models[m.id] = {
+              id: ModelID.make(m.id),
+              providerID: ProviderID.make("maple"),
+              name: m.id,
+              api: {
+                id: m.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: {},
+            }
           }
-          const data = await response.json() as { data?: Array<{ id: string }> }
-          return data.data ?? []
-        },
-        catch: (e) => {
-          log.warn("Failed to connect to Maple proxy", { error: e })
-          return new Error(String(e))
-        },
-      }).pipe(Effect.orElseSucceed(() => [] as Array<{ id: string }>))
-
-      for (const model of models) {
-        input.models[model.id] = {
-          id: ModelID.make(model.id),
-          providerID: ProviderID.make("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: {},
-        }
-      }
-
-      return {
-        autoload: Object.keys(input.models).length > 0,
-        options: {
-          baseURL,
-          apiKey,
+          return models
         },
       }
     }),
@@ -1360,18 +1350,20 @@ const layer: Layer.Layer<
           mergeProvider(providerID, partial)
         }
 
-        const gitlab = ProviderID.make("gitlab")
-        if (discoveryLoaders[gitlab] && providers[gitlab] && isProviderAllowed(gitlab)) {
+        for (const [id, discover] of Object.entries(discoveryLoaders)) {
+          const providerID = ProviderID.make(id)
+          if (!providers[providerID] || !isProviderAllowed(providerID)) continue
           yield* Effect.promise(async () => {
             try {
-              const discovered = await discoveryLoaders[gitlab]()
+              const discovered = await discover()
               for (const [modelID, model] of Object.entries(discovered)) {
-                if (!providers[gitlab].models[modelID]) {
-                  providers[gitlab].models[modelID] = model
+                if (!providers[providerID].models[modelID]) {
+                  model.providerID = providerID
+                  providers[providerID].models[modelID] = model
                 }
               }
             } catch (e) {
-              log.warn("state discovery error", { id: "gitlab", error: e })
+              log.warn("state discovery error", { id, error: e })
             }
           })
         }