@@ -713,6 +713,83 @@ function custom(dep: CustomDep): Record<string, CustomLoader> {
         },
       }
     }),
+    helexa: Effect.fnUntraced(function* (input: Info) {
+      const auth = yield* dep.auth(input.id)
+      const env = yield* dep.env()
+      const apiKey =
+        auth?.type === "api" ? auth.key : auth?.type === "oauth" ? auth.access : env["HELEXA_API_KEY"]
+      // Endpoint resolution: the provider `baseURL` option (config) or the
+      // HELEXA_ENDPOINT env var. There is no hardcoded default yet — no
+      // canonical public router exists — so helexa activates only when an
+      // endpoint is explicitly configured. A router default can be added here
+      // once a canonical gateway URL exists (helexa#61).
+      const baseURL = (input.options?.baseURL as string | undefined) ?? env["HELEXA_ENDPOINT"]
+      return {
+        // Activate only with an explicit endpoint; without one there is nowhere
+        // to discover from. An API key alone is insufficient.
+        autoload: !!baseURL,
+        options: baseURL ? { baseURL, apiKey } : {},
+        // Discover the live catalog from the resolved endpoint. helexa serves
+        // per-model limits/cost (helexa#62); we map them onto opencode models so
+        // context %, compaction headroom, and spend all work with zero config.
+        async discoverModels(): Promise<Record<string, Model>> {
+          if (!baseURL) return {}
+          const modelsURL = new URL("models", baseURL.endsWith("/") ? baseURL : baseURL + "/")
+          try {
+            const res = await fetch(modelsURL, {
+              headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+            })
+            if (!res.ok) return {}
+            const body = (await res.json()) as any
+            const list: any[] = Array.isArray(body) ? body : (body?.data ?? body?.models ?? [])
+            const models: Record<string, Model> = {}
+            for (const m of list) {
+              const id: string | undefined = m?.id
+              if (!id) continue
+              const caps: string[] = Array.isArray(m?.capabilities) ? m.capabilities : []
+              const vision = caps.includes("vision")
+              models[ModelV2.ID.make(id)] = {
+                id: ModelV2.ID.make(id),
+                providerID: ProviderV2.ID.make("helexa"),
+                name: typeof m?.name === "string" ? m.name : id,
+                family: "",
+                api: { id, url: baseURL, npm: "@ai-sdk/openai-compatible" },
+                status: "active",
+                headers: {},
+                options: {},
+                cost: {
+                  input: m?.cost?.input ?? 0,
+                  output: m?.cost?.output ?? 0,
+                  cache: {
+                    read: m?.cost?.cache_read ?? 0,
+                    write: m?.cost?.cache_write ?? 0,
+                  },
+                },
+                limit: {
+                  context: m?.limit?.context ?? 0,
+                  input: m?.limit?.input,
+                  output: m?.limit?.output ?? 0,
+                },
+                capabilities: {
+                  temperature: true,
+                  reasoning: !!m?.reasoning,
+                  attachment: vision,
+                  toolcall: m?.tool_call ?? true,
+                  input: { text: true, audio: false, image: vision, video: false, pdf: false },
+                  output: { text: true, audio: false, image: false, video: false, pdf: false },
+                  interleaved: false,
+                },
+                release_date: "",
+                variants: {},
+              }
+            }
+            return models
+          } catch (e) {
+            return {}
+          }
+        },
+      }
+    }),
     "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.
@@ -1297,7 +1374,25 @@ export const layer = Layer.effect(
       Effect.gen(function* () {
         const bridge = yield* EffectBridge.make()
         const cfg = yield* config.get()
-        const modelsDev = yield* modelsDevSvc.get()
+        // Built-in helexa provider seed. helexa is a self-hosted, distributed
+        // mesh and is not published to the public models.dev catalog, so seed a
+        // minimal provider entry here so that setting HELEXA_ENDPOINT (or a
+        // provider baseURL) alone activates it — no opencode.json provider stanza
+        // needed. The endpoint is resolved at load time by the custom() loader,
+        // which also discovers the model list (per-model limits/cost). `api` is
+        // left empty: there is no canonical default endpoint yet (helexa#61).
+        // A real models.dev entry, if one is ever added, takes precedence.
+        const modelsDev: Record<string, ModelsDev.Provider> = {
+          helexa: {
+            id: "helexa",
+            name: "Helexa",
+            env: ["HELEXA_API_KEY"],
+            npm: "@ai-sdk/openai-compatible",
+            api: "",
+            models: {},
+          },
+          ...(yield* modelsDevSvc.get()),
+        }
         const catalog = mapValues(modelsDev, fromModelsDevProvider)
         const database = mapValues(catalog, toPublicInfo)
 
@@ -1543,14 +1638,18 @@ export const layer = Layer.effect(
           mergeProvider(providerID, partial)
         }
 
-        const gitlab = ProviderV2.ID.make("gitlab")
-        if (discoveryLoaders[gitlab] && providers[gitlab] && isProviderAllowed(gitlab)) {
+        // Run model discovery for any provider that registered a discoverModels
+        // loader (gitlab, helexa, ...). Discovered models are additive — they
+        // never clobber models already present from models.dev or config.
+        for (const id of Object.keys(discoveryLoaders)) {
+          const providerID = ProviderV2.ID.make(id)
+          if (!providers[providerID] || !isProviderAllowed(providerID)) continue
           yield* Effect.promise(async () => {
             try {
-              const discovered = await discoveryLoaders[gitlab]()
+              const discovered = await discoveryLoaders[providerID]()
               for (const [modelID, model] of Object.entries(discovered)) {
-                if (!providers[gitlab].models[modelID]) {
-                  providers[gitlab].models[modelID] = model
+                if (!providers[providerID].models[modelID]) {
+                  providers[providerID].models[modelID] = model
                 }
               }
             } catch (e) {}