feat: add OpenCode Go as a subscription provider (#1520)

* feat: add OpenCode Go as a subscription provider

Add OpenCode Go to the routing layer as a token-based subscription provider.
The model list is fetched dynamically from the public OpenCode Go docs source
and cached in memory for one hour, with a last-known-good fallback on fetch
failures — no hardcoded model list in the codebase.

The proxy routes GLM, Kimi, and MiMo models through the OpenAI-compatible
`/v1/chat/completions` endpoint and both MiniMax models through the
Anthropic-compatible `/v1/messages` endpoint, both served from the same
`https://opencode.ai/zen/go` base URL. The Anthropic endpoint authenticates
via `x-api-key` (not `Authorization: Bearer`), matching the native Anthropic
wire protocol that OpenCode Go's upstream expects.

In the UI, OpenCode Go lives in the subscription tab with a custom sign-in
button that opens opencode.ai/auth in a new tab; users copy their API key
from the dashboard and paste it into the token field. The existing token
paste flow on `ProviderDetailView` is now data-driven via three new optional
fields on `ProviderDef` (`subscriptionSignInUrl`, `subscriptionSignInLabel`,
`subscriptionSignInHint`).

* fix: use real OpenCode brand mark for opencode-go icon

Replace the placeholder square/block approximation with the actual OpenCode
logo (fetched from https://opencode.ai/favicon.svg). The glyph has a dark
background, a white rounded outer frame, and a gray inner fill — it's the
same mark the OpenCode website and docs use.

Plugin public assets regenerated so the bundled dashboard ships the new icon
alongside the new Z.ai subscription provider from main.

* test: raise patch coverage on opencode-go catalog and icon

- Add ProviderIcon smoke test for 'opencode-go' so the new case arm is
  covered (frontend coverage dropped from 98.58 to 98.56 on the initial
  push because the icon was never rendered in any test).
- Drop the dead header-row skip in OpencodeGoCatalogService.parse; the
  regex already filters header rows via its lowercase-anchored model-id
  group. Comment in place explaining why.
- Add a non-Error throw test to exercise the String(err) fallback in
  OpencodeGoCatalogService.list.

* fix: address review feedback

Cubic flagged (P2) that after the success TTL expired, a failing fetch
would return the last-known-good list but never refresh cache.expiresAt,
so every subsequent call would hit the network again — turning a
sustained outage into a per-call retry storm.

Introduce a short ERROR_BACKOFF_MS (5 minutes) and funnel all failure
paths (non-ok response, zero-row parse, thrown exception) through a
single cacheFallback helper that writes a short-lived cache entry.
Successful fetches still use the full 1 hour TTL.

* fix: polish OpenCode Go provider detail view

- Use official brand logos with light/dark mode variants
- Make sign-in button small and dark (btn--primary btn--sm)
- Add beta badge next to provider name
- Simplify sign-in hint text

---------

Co-authored-by: Sébastien Conejo <sebastien@buddyweb.fr>

Author: brunobuddy

.changeset/add-opencode-go-subscription.md

@@ -0,0 +1,17 @@
+---
+"manifest": minor
+---
+
+feat: add OpenCode Go as a subscription provider with dynamic model discovery
+
+OpenCode Go is a low-cost subscription that exposes GLM, Kimi, MiMo, and MiniMax
+models through a unified API. Users sign in at opencode.ai/auth, copy their API
+key, and paste it into the OpenCode Go detail view in the routing UI. The backend
+routes GLM/Kimi/MiMo models through the OpenAI-compatible endpoint and MiniMax
+models through the Anthropic-compatible endpoint — both served from the same
+`https://opencode.ai/zen/go` base URL. The Anthropic endpoint authenticates via
+`x-api-key` (not Bearer), matching the native Anthropic wire protocol.
+
+The model list is fetched dynamically from the public OpenCode Go docs source
+and cached in memory for one hour, with a last-known-good fallback on fetch
+failures. No hardcoded model list in the codebase.

packages/backend/src/common/constants/providers.spec.ts

@@ -9,8 +9,8 @@ import {
 } from './providers';
 
 describe('PROVIDER_REGISTRY', () => {
-  it('should contain exactly 14 provider entries', () => {
-    expect(PROVIDER_REGISTRY).toHaveLength(14);
+  it('should contain exactly 15 provider entries', () => {
+    expect(PROVIDER_REGISTRY).toHaveLength(15);
   });
 
   it('ollama-cloud has localOnly=false and requiresApiKey=false', () => {
@@ -79,14 +79,24 @@ describe('PROVIDER_REGISTRY', () => {
     expect(copilot!.aliases).toEqual([]);
     expect(copilot!.openRouterPrefixes).toEqual([]);
   });
+
+  it('opencode-go is registered with opencodego alias and no OpenRouter prefix', () => {
+    const og = PROVIDER_REGISTRY.find((p) => p.id === 'opencode-go');
+    expect(og).toBeDefined();
+    expect(og!.displayName).toBe('OpenCode Go');
+    expect(og!.aliases).toEqual(['opencodego']);
+    expect(og!.openRouterPrefixes).toEqual([]);
+    expect(og!.requiresApiKey).toBe(true);
+    expect(og!.localOnly).toBe(false);
+  });
 });
 
 describe('PROVIDER_BY_ID', () => {
-  it('resolves all 14 provider IDs', () => {
+  it('resolves all 15 provider IDs', () => {
     for (const entry of PROVIDER_REGISTRY) {
       expect(PROVIDER_BY_ID.get(entry.id)).toBe(entry);
     }
-    expect(PROVIDER_BY_ID.size).toBe(14);
+    expect(PROVIDER_BY_ID.size).toBe(15);
   });
 
   it('returns undefined for an unknown ID', () => {

packages/backend/src/common/constants/providers.ts

@@ -125,6 +125,14 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     requiresApiKey: false,
     localOnly: false,
   },
+  {
+    id: 'opencode-go',
+    displayName: 'OpenCode Go',
+    aliases: ['opencodego'],
+    openRouterPrefixes: [],
+    requiresApiKey: true,
+    localOnly: false,
+  },
   {
     id: 'openrouter',
     displayName: 'OpenRouter',

packages/backend/src/model-discovery/model-discovery.module.ts

@@ -5,11 +5,17 @@ import { CustomProvider } from '../entities/custom-provider.entity';
 import { ModelPricesModule } from '../model-prices/model-prices.module';
 import { ProviderModelFetcherService } from './provider-model-fetcher.service';
 import { ModelDiscoveryService } from './model-discovery.service';
+import { OpencodeGoCatalogService } from './opencode-go-catalog.service';
 import { CopilotTokenService } from '../routing/proxy/copilot-token.service';
 
 @Module({
   imports: [TypeOrmModule.forFeature([UserProvider, CustomProvider]), ModelPricesModule],
-  providers: [ProviderModelFetcherService, ModelDiscoveryService, CopilotTokenService],
-  exports: [ModelDiscoveryService, ProviderModelFetcherService],
+  providers: [
+    ProviderModelFetcherService,
+    ModelDiscoveryService,
+    OpencodeGoCatalogService,
+    CopilotTokenService,
+  ],
+  exports: [ModelDiscoveryService, ProviderModelFetcherService, OpencodeGoCatalogService],
 })
 export class ModelDiscoveryModule {}

packages/backend/src/model-discovery/model-fallback.spec.ts

@@ -279,6 +279,13 @@ describe('buildSubscriptionFallbackModels', () => {
 
     expect(result.length).toBeGreaterThanOrEqual(1);
   });
+
+  it('returns [] for opencode-go because its catalog is fetched dynamically', () => {
+    // OpenCode Go has no hardcoded knownModels. The fallback path must stay empty
+    // so we do not fabricate stale entries when the live catalog is unreachable.
+    const result = buildSubscriptionFallbackModels(makePricingSync(new Map()), 'opencode-go');
+    expect(result).toEqual([]);
+  });
 });
 
 describe('supplementWithKnownModels', () => {

packages/backend/src/model-discovery/opencode-go-catalog.service.spec.ts

@@ -0,0 +1,173 @@
+import { OpencodeGoCatalogService } from './opencode-go-catalog.service';
+
+const BT = String.fromCharCode(96);
+const OAI = BT + 'https://opencode.ai/zen/go/v1/chat/completions' + BT;
+const ANT = BT + 'https://opencode.ai/zen/go/v1/messages' + BT;
+const OAI_SDK = BT + '@ai-sdk/openai-compatible' + BT;
+const ANT_SDK = BT + '@ai-sdk/anthropic' + BT;
+
+const SAMPLE_MDX = [
+  '---',
+  'title: Go',
+  'description: Low cost subscription for open coding models.',
+  '---',
+  '',
+  '## Endpoints',
+  '',
+  '| Model        | Model ID     | Endpoint                                         | AI SDK Package              |',
+  '| ------------ | ------------ | ------------------------------------------------ | --------------------------- |',
+  `| GLM-5.1      | glm-5.1      | ${OAI} | ${OAI_SDK} |`,
+  `| GLM-5        | glm-5        | ${OAI} | ${OAI_SDK} |`,
+  `| Kimi K2.5    | kimi-k2.5    | ${OAI} | ${OAI_SDK} |`,
+  `| MiMo-V2-Pro  | mimo-v2-pro  | ${OAI} | ${OAI_SDK} |`,
+  `| MiMo-V2-Omni | mimo-v2-omni | ${OAI} | ${OAI_SDK} |`,
+  `| MiniMax M2.7 | minimax-m2.7 | ${ANT} | ${ANT_SDK} |`,
+  `| MiniMax M2.5 | minimax-m2.5 | ${ANT} | ${ANT_SDK} |`,
+  '',
+].join('\n');
+
+describe('OpencodeGoCatalogService', () => {
+  let service: OpencodeGoCatalogService;
+  let fetchSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    service = new OpencodeGoCatalogService();
+    fetchSpy = jest.spyOn(global, 'fetch');
+  });
+
+  afterEach(() => {
+    fetchSpy.mockRestore();
+  });
+
+  describe('parse', () => {
+    it('extracts every model in the endpoints table', () => {
+      const entries = service.parse(SAMPLE_MDX);
+      expect(entries.map((e) => e.id)).toEqual([
+        'glm-5.1',
+        'glm-5',
+        'kimi-k2.5',
+        'mimo-v2-pro',
+        'mimo-v2-omni',
+        'minimax-m2.7',
+        'minimax-m2.5',
+      ]);
+    });
+
+    it('keeps the docs display name verbatim', () => {
+      const entries = service.parse(SAMPLE_MDX);
+      const labels = Object.fromEntries(entries.map((e) => [e.id, e.displayName]));
+      expect(labels['glm-5.1']).toBe('GLM-5.1');
+      expect(labels['kimi-k2.5']).toBe('Kimi K2.5');
+      expect(labels['mimo-v2-omni']).toBe('MiMo-V2-Omni');
+      expect(labels['minimax-m2.7']).toBe('MiniMax M2.7');
+    });
+
+    it('tags MiniMax rows as anthropic and everything else as openai', () => {
+      const entries = service.parse(SAMPLE_MDX);
+      const byId = Object.fromEntries(entries.map((e) => [e.id, e.format]));
+      expect(byId['glm-5.1']).toBe('openai');
+      expect(byId['kimi-k2.5']).toBe('openai');
+      expect(byId['mimo-v2-pro']).toBe('openai');
+      expect(byId['minimax-m2.5']).toBe('anthropic');
+      expect(byId['minimax-m2.7']).toBe('anthropic');
+    });
+
+    it('never matches the header row (uppercase model ID column fails regex)', () => {
+      // The regex anchors the model-id group on [a-z], so "Model ID" in the
+      // header row column does not match. No explicit skip needed.
+      const entries = service.parse(SAMPLE_MDX);
+      expect(entries.find((e) => e.displayName === 'Model')).toBeUndefined();
+      expect(entries.find((e) => e.id === 'model id')).toBeUndefined();
+    });
+
+    it('returns an empty array when the table is missing', () => {
+      expect(service.parse('# Go\n\nNo table here.')).toEqual([]);
+    });
+
+    it('deduplicates if a model appears twice', () => {
+      const doubled = SAMPLE_MDX + '\n' + SAMPLE_MDX;
+      const entries = service.parse(doubled);
+      const ids = entries.map((e) => e.id);
+      expect(new Set(ids).size).toBe(ids.length);
+    });
+  });
+
+  describe('list', () => {
+    it('fetches, parses, and caches the catalog', async () => {
+      fetchSpy.mockResolvedValue({
+        ok: true,
+        status: 200,
+        text: async () => SAMPLE_MDX,
+      } as Response);
+
+      const first = await service.list();
+      expect(first).toHaveLength(7);
+      expect(fetchSpy).toHaveBeenCalledTimes(1);
+
+      const second = await service.list();
+      expect(second).toBe(first);
+      expect(fetchSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('returns the last good result when a later fetch fails', async () => {
+      fetchSpy.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: async () => SAMPLE_MDX,
+      } as Response);
+      const good = await service.list();
+      expect(good).toHaveLength(7);
+
+      // Force the success cache to look expired, but keep lastGood populated.
+      (service as unknown as { cache: unknown }).cache = null;
+
+      fetchSpy.mockResolvedValueOnce({ ok: false, status: 500 } as Response);
+      const afterFailure = await service.list();
+      expect(afterFailure).toEqual(good);
+    });
+
+    it('backs off after a failure so repeated calls do not hammer the network', async () => {
+      // First fetch fails with nothing cached → returns [] and arms the
+      // error-backoff window.
+      fetchSpy.mockResolvedValueOnce({ ok: false, status: 503 } as Response);
+      const first = await service.list();
+      expect(first).toEqual([]);
+      expect(fetchSpy).toHaveBeenCalledTimes(1);
+
+      // Second call within the backoff window reuses the cached fallback and
+      // must NOT reach the network.
+      const second = await service.list();
+      expect(second).toEqual([]);
+      expect(fetchSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('returns [] when there is no prior cache and the fetch 404s', async () => {
+      fetchSpy.mockResolvedValue({ ok: false, status: 404 } as Response);
+      const result = await service.list();
+      expect(result).toEqual([]);
+    });
+
+    it('returns [] when the fetch throws an Error and nothing is cached', async () => {
+      fetchSpy.mockRejectedValue(new Error('network down'));
+      const result = await service.list();
+      expect(result).toEqual([]);
+    });
+
+    it('returns [] when the fetch throws a non-Error value', async () => {
+      // Exercises the String(err) fallback when something non-Error is thrown.
+      fetchSpy.mockRejectedValue('raw string failure');
+      const result = await service.list();
+      expect(result).toEqual([]);
+    });
+
+    it('returns [] (not stale empty) when the docs parse to zero rows', async () => {
+      fetchSpy.mockResolvedValue({
+        ok: true,
+        status: 200,
+        text: async () => '# Nothing useful here',
+      } as Response);
+      const result = await service.list();
+      expect(result).toEqual([]);
+    });
+  });
+});

packages/backend/src/model-discovery/opencode-go-catalog.service.ts

@@ -0,0 +1,102 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+export interface OpencodeGoCatalogEntry {
+  /** Bare model ID as listed in the docs (e.g. "glm-5.1"). */
+  id: string;
+  /** Human-readable display name from the docs (e.g. "GLM-5.1"). */
+  displayName: string;
+  /** Which upstream API format the model expects. */
+  format: 'openai' | 'anthropic';
+}
+
+const CATALOG_URL =
+  'https://raw.githubusercontent.com/anomalyco/opencode/dev/packages/web/src/content/docs/go.mdx';
+const CACHE_TTL_MS = 60 * 60 * 1000;
+// After a fetch failure we reuse the last-known-good list for a shorter window
+// so a sustained outage does not turn into a per-call retry storm.
+const ERROR_BACKOFF_MS = 5 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 10_000;
+
+/**
+ * Fetches the OpenCode Go model list from the public docs source.
+ * OpenCode Go has no /v1/models endpoint, so the canonical list lives
+ * in the markdown docs file the website renders from. We parse the
+ * Endpoints table and cache the result in memory.
+ */
+@Injectable()
+export class OpencodeGoCatalogService {
+  private readonly logger = new Logger(OpencodeGoCatalogService.name);
+  private cache: { entries: OpencodeGoCatalogEntry[]; expiresAt: number } | null = null;
+  private lastGood: OpencodeGoCatalogEntry[] | null = null;
+
+  async list(): Promise<OpencodeGoCatalogEntry[]> {
+    const now = Date.now();
+    if (this.cache && this.cache.expiresAt > now) {
+      return this.cache.entries;
+    }
+
+    try {
+      const response = await fetch(CATALOG_URL, {
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+      });
+      if (!response.ok) {
+        this.logger.warn(`OpenCode Go catalog fetch returned ${response.status}`);
+        return this.cacheFallback(now);
+      }
+      const mdx = await response.text();
+      const entries = this.parse(mdx);
+      if (entries.length === 0) {
+        this.logger.warn('OpenCode Go catalog parsed zero entries — docs format may have changed');
+        return this.cacheFallback(now);
+      }
+      this.cache = { entries, expiresAt: now + CACHE_TTL_MS };
+      this.lastGood = entries;
+      this.logger.log(`OpenCode Go catalog loaded: ${entries.length} models`);
+      return entries;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.logger.warn(`OpenCode Go catalog fetch failed: ${message}`);
+      return this.cacheFallback(now);
+    }
+  }
+
+  /**
+   * Set a short error-backoff cache so repeated calls during an outage do not
+   * hammer the network, then return the last-known-good list (or []).
+   */
+  private cacheFallback(now: number): OpencodeGoCatalogEntry[] {
+    const entries = this.lastGood ?? [];
+    this.cache = { entries, expiresAt: now + ERROR_BACKOFF_MS };
+    return entries;
+  }
+
+  /** Parse the Endpoints markdown table out of the go.mdx source. */
+  parse(mdx: string): OpencodeGoCatalogEntry[] {
+    const rowRe =
+      /\|\s*([A-Za-z][^|]*?)\s*\|\s*([a-z][a-z0-9.-]*)\s*\|\s*`?https:\/\/opencode\.ai\/zen\/go\/v1\/(chat\/completions|messages)`?\s*\|/g;
+    const entries: OpencodeGoCatalogEntry[] = [];
+    const seen = new Set<string>();
+    let match: RegExpExecArray | null;
+    while ((match = rowRe.exec(mdx)) !== null) {
+      const [, rawName, modelId, endpointSuffix] = match;
+      const displayName = rawName.trim();
+      // The header row never matches: "Model ID" starts uppercase, failing the
+      // lowercase-anchored modelId group. Dash separator rows likewise start
+      // with '-', not [A-Za-z]. So any row reaching this point is a data row.
+      if (seen.has(modelId)) continue;
+      seen.add(modelId);
+      entries.push({
+        id: modelId,
+        displayName,
+        format: endpointSuffix === 'messages' ? 'anthropic' : 'openai',
+      });
+    }
+    return entries;
+  }
+
+  /** Test hook: clear in-memory state. */
+  resetCache(): void {
+    this.cache = null;
+    this.lastGood = null;
+  }
+}