From aadd4d861458d66af9bc3994b428d829b54eaa60 Mon Sep 17 00:00:00 2001 From: Dax Date: Tue, 20 Oct 2026 22:18:42 -0400 Subject: [PATCH] feat(core): add OPENCODE_DISABLE_FREE_MODELS to hide free models (#57478) --- packages/core/src/model.ts | 6 ++ packages/core/src/plugin/provider/opencode.ts | 3 +- packages/core/test/model-free.test.ts | 90 +++++++++++++++++++ .../test/plugin/provider-opencode.test.ts | 55 ++++++++++++ .../www/src/docs/content/console/models.mdx | 2 + services/www/src/docs/content/models.mdx | 18 ++++ 6 files changed, 173 insertions(+), 1 deletion(-) create mode 100644 packages/core/test/model-free.test.ts diff --git a/packages/core/src/model.ts b/packages/core/src/model.ts index c0246ee9bd3..7a199b6c5d7 100644 --- a/packages/core/src/model.ts +++ b/packages/core/src/model.ts @@ -92,6 +92,7 @@ const layer = Layer.effect( const providers = yield* Provider.Service const bus = yield* Bus.Service const location = yield* Location.Service + const disableFree = ["1", "true"].includes(process.env.OPENCODE_DISABLE_FREE_MODELS?.toLowerCase() ?? "") let input: Provider.Snapshot | undefined const state: State.Interface = State.create({ name: "model", @@ -220,6 +221,11 @@ const layer = Layer.effect( ] }), ) + if (disableFree) + for (const providerID of [Provider.ID.opencode, Provider.ID.make("opencode-go")]) + byProvider.get(providerID)?.forEach((model, id, models) => { + if (!model.cost.some((cost) => cost.input > 0)) models.delete(id) + }) const all = Array.from(byProvider.values()) .flatMap((models) => Array.from(models.values())) .sort((left, right) => right.time.released - left.time.released) diff --git a/packages/core/src/plugin/provider/opencode.ts b/packages/core/src/plugin/provider/opencode.ts index 0d2250346b8..d2e3cee159e 100644 --- a/packages/core/src/plugin/provider/opencode.ts +++ b/packages/core/src/plugin/provider/opencode.ts @@ -197,6 +197,7 @@ function oauth(http: HttpClient.HttpClient) { export const OpencodePlugin = define({ id: "opencode.provider.opencode", effect: Effect.fn(function* (ctx) { + const disableFree = ["1", "true"].includes(process.env.OPENCODE_DISABLE_FREE_MODELS?.toLowerCase() ?? "") const bus = yield* Bus.Service const client = yield* HttpClient.HttpClient // Every request here goes to the Console, which reads the User-Agent to tell which OpenCode a member runs @@ -366,7 +367,7 @@ export const OpencodePlugin = define { - if (!hasKey) { + if (!hasKey && !disableFree) { provider.activation = "enabled" provider.settings = { ...provider.settings, apiKey: "public" } } diff --git a/packages/core/test/model-free.test.ts b/packages/core/test/model-free.test.ts new file mode 100644 index 00000000000..cc61728c21e --- /dev/null +++ b/packages/core/test/model-free.test.ts @@ -0,0 +1,90 @@ +import { expect } from "bun:test" +import { DateTime, Effect, Layer } from "effect" +import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder" +import { LayerNode } from "@opencode/util/effect/layer-node" +import { Location } from "@opencode/core/location" +import { Model } from "@opencode/core/model" +import { ModelResolver } from "@opencode/core/model-resolver" +import { Project } from "@opencode/core/project" +import { Provider } from "@opencode/core/provider" +import { AbsolutePath } from "@opencode/core/schema" +import { Session } from "@opencode/core/session" +import { SessionRunnerModel } from "@opencode/core/session/runner/model" +import { Money } from "@opencode/schema/money" +import { withEnv } from "./fixture/env" +import { location } from "./fixture/location" +import { it } from "./lib/effect" + +const ref = location({ directory: AbsolutePath.make("test") }) +const layer = AppNodeBuilder.build( + LayerNode.group([Provider.node, Model.node, ModelResolver.node, SessionRunnerModel.node]), + [Location.node.replace(Layer.succeed(Location.Service, Location.Service.of(ref)))], +) +const free = Model.ID.make("big-pickle") +const paid = Model.ID.make("paid") +const local = Model.ID.make("local") +const other = Provider.ID.make("other") + +for (const flag of [undefined, "0", "1", "true"]) { + for (const providerID of [Provider.ID.opencode, Provider.ID.make("opencode-go")]) + it.effect(`${providerID} catalog with OPENCODE_DISABLE_FREE_MODELS=${flag}`, () => + withEnv({ OPENCODE_DISABLE_FREE_MODELS: flag }, () => + Effect.gen(function* () { + const providers = yield* Provider.Service + const models = yield* Model.Service + const runner = yield* SessionRunnerModel.Service + const resolver = yield* ModelResolver.Service + yield* providers.transform((editor) => { + editor.update(providerID, () => {}) + editor.models.update(providerID, free, (model) => { + model.time.released = 3000 + model.family = Model.Family.make("gpt-luna") + model.capabilities = { ...model.capabilities, input: ["text"], output: ["text"] } + }) + editor.models.update(providerID, paid, (model) => { + model.time.released = 2000 + model.cost = [ + { + input: Money.USDPerMillionTokens.make(1), + output: Money.USDPerMillionTokens.zero, + cache: { read: Money.USDPerMillionTokens.zero, write: Money.USDPerMillionTokens.zero }, + }, + ] + }) + editor.update(other, () => {}) + editor.models.update(other, local, () => {}) + }) + yield* models.transform((editor) => editor.default.set(providerID, free)) + const disabled = flag === "1" || flag === "true" + expect((yield* models.all()).map((model) => model.id)).toEqual(disabled ? [paid, local] : [free, paid, local]) + expect(yield* models.available()).toEqual(yield* models.all()) + expect((yield* models.default())?.id).toBe(disabled ? paid : free) + expect((yield* models.get(providerID, free))?.id).toBe(disabled ? undefined : free) + expect((yield* models.small(providerID))?.id).toBe(disabled ? undefined : free) + if (!disabled) return + const session = Session.Info.make({ + id: Session.ID.make("ses_free_model"), + projectID: Project.ID.global, + title: "test", + model: { id: free, providerID }, + cost: Money.USD.zero, + tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, + time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) }, + location: ref, + }) + const failure = yield* runner.resolve(session, models.available).pipe(Effect.flip) + expect(failure.message).toBe(`Model unavailable: ${providerID}/big-pickle`) + expect(yield* resolver.resolve(Model.Ref.make({ providerID, id: free }))).toBeUndefined() + // Later transforms cannot restore a free model, even when all paid models are removed. + yield* models.transform((editor) => { + editor.update(providerID, free, (model) => { + model.enabled = true + }) + editor.remove(providerID, paid) + }) + expect((yield* models.default())?.providerID).toBe(other) + expect(yield* models.get(providerID, free)).toBeUndefined() + }).pipe(Effect.provide(layer)), + ), + ) +} diff --git a/packages/core/test/plugin/provider-opencode.test.ts b/packages/core/test/plugin/provider-opencode.test.ts index dd93d600db7..b7db1e7fbf3 100644 --- a/packages/core/test/plugin/provider-opencode.test.ts +++ b/packages/core/test/plugin/provider-opencode.test.ts @@ -2027,3 +2027,58 @@ describe("OpencodePlugin", () => { ), ) }) + +for (const key of [undefined, "secret"]) { + testEffect(Layer.empty).effect( + `disabled free models with ${key ? "an API key" : "a Console login after startup"}`, + () => + withEnv({ OPENCODE_DISABLE_FREE_MODELS: "true", OPENCODE_API_KEY: key }, () => + Effect.gen(function* () { + const catalog = yield* Provider.Service + const models = yield* Model.Service + const integrations = yield* Integration.Service + const credentials = yield* Credential.Service + yield* integrations.transform((editor) => + editor.method.update({ + integrationID: Integration.ID.make("opencode"), + method: { type: "env", names: ["OPENCODE_API_KEY"] }, + }), + ) + yield* catalog.transform((editor) => { + editor.update(Provider.ID.opencode, () => {}) + editor.models.update(Provider.ID.opencode, Model.ID.make("free"), (model) => { + model.cost = cost(0) + }) + editor.models.update(Provider.ID.opencode, Model.ID.make("paid"), (model) => { + model.cost = cost(1) + }) + }) + yield* addPlugin().pipe(Effect.provideService(HttpClient.HttpClient, noRemoteConfig)) + if (!key) { + expect(yield* catalog.available()).toEqual([]) + expect(yield* models.all()).toEqual([]) + expect(yield* models.default()).toBeUndefined() + expect((yield* integrations.get(Integration.ID.make("opencode")))?.methods.length).toBeGreaterThan(0) + yield* credentials.create({ + integrationID: Integration.ID.make("opencode"), + value: Credential.OAuth.make({ + type: "oauth", + methodID: Integration.MethodID.make("device"), + access: "access", + refresh: "refresh", + expires: Date.now() + 600_000, + }), + }) + } + const available = yield* eventually(models.available(), (models) => + models.some((model) => model.providerID === Provider.ID.opencode), + ) + expect((yield* catalog.available()).map((provider) => provider.id)).toContain(Provider.ID.opencode) + expect(available.map((model) => model.id)).toEqual([Model.ID.make("paid")]) + expect(yield* models.all()).toEqual(available) + expect((yield* models.default())?.id).toBe(Model.ID.make("paid")) + expect(yield* models.get(Provider.ID.opencode, Model.ID.make("free"))).toBeUndefined() + }).pipe(Effect.provide(PluginTestLayer)), + ), + ) +} diff --git a/services/www/src/docs/content/console/models.mdx b/services/www/src/docs/content/console/models.mdx index 5e00f44308d..4431db0bf29 100644 --- a/services/www/src/docs/content/console/models.mdx +++ b/services/www/src/docs/content/console/models.mdx @@ -337,6 +337,8 @@ models to generate session titles. - LongCat 2.5 Preview Free is free on OpenCode for a limited time. Its provider follows a zero-retention policy and does not use your data for model training. - Jev 1.13 Free is available on OpenCode for a limited time. +To hide free models in OpenCode, set `OPENCODE_DISABLE_FREE_MODELS=1`. See [free models](/models#free-models). + [Contact us](mailto:help@anoma.ly) if you have any questions. ### Auto-recharge and budgets diff --git a/services/www/src/docs/content/models.mdx b/services/www/src/docs/content/models.mdx index 6549acc2d29..b23204cbc42 100644 --- a/services/www/src/docs/content/models.mdx +++ b/services/www/src/docs/content/models.mdx @@ -57,6 +57,24 @@ falls back to the newest available supported model. See [Config](/config) for configuration locations and precedence. +## Free models + +Set `OPENCODE_DISABLE_FREE_MODELS=1` (or `true`) on the server process to hide [free OpenCode models](/console/models#free-models): + +```bash +OPENCODE_DISABLE_FREE_MODELS=1 opencode serve +``` + +For the shared background server: + +```bash +opencode service set env OPENCODE_DISABLE_FREE_MODELS 1 +``` + +Free means an `opencode` or `opencode-go` model with no input price. These models disappear from the catalog and defaults; +explicitly selecting one fails with `Model unavailable`. Signed out, the `opencode` provider is absent until you connect +an OpenCode Console account or set `OPENCODE_API_KEY`, which restores its paid models. + ## Variants Variants are named options for one model, often used for reasoning effort or token budgets. Add `#variant` when selecting