mixdog 1.2.5 → 1.3.0

package/src/runtime/agent/orchestrator/providers/opencode-go-oauth.mjs

@@ -0,0 +1,293 @@
+/**
+ * OpenCode Go through an OpenCode Console OAuth login.
+ *
+ * The organization's remote config (`/api/v2/config` → providers.opencode-go)
+ * is the authority for the inference base URL, the request headers and the
+ * model catalog (the gateway's own `/models` is not served on this base).
+ * Requests run on the OpenCode Go gateway engines (opencode-go.mjs) with the
+ * access token as the bearer; a 401 refreshes the token once and retries.
+ */
+import { scrubOAuthSecrets } from './lib/oauth-token-utils.mjs';
+import { getModelMetadataSync } from './model-catalog.mjs';
+import { makeModelCache } from './model-cache.mjs';
+import { OpenCodeGoProvider, WIRE_API_BY_NPM, resolveOpenCodeGoWireRoute } from './opencode-go.mjs';
+import { fetchOpenCodeGoOAuthUsageSnapshot } from './opencode-go-usage.mjs';
+import {
+  CONFIG_PROVIDER_KEY,
+  CONFIG_URL,
+  FALLBACK_BASE_URL,
+  PROVIDER_ID,
+  consoleGetJson,
+  ensureFreshTokens,
+  loadTokens,
+  openCodeGoError,
+  openCodeGoReauthError,
+} from './opencode-go-oauth-tokens.mjs';
+
+export {
+  hasOpenCodeGoOAuthCredentials,
+  describeOpenCodeGoOAuthCredentials,
+  forgetOpenCodeGoOAuthCredentials,
+} from './opencode-go-oauth-tokens.mjs';
+export { beginOAuthLogin, loginOAuth } from './opencode-go-oauth-login.mjs';
+
+const CONFIG_TTL_MS = 10 * 60_000;
+
+// The catalog the remote config listed, with the base URL and headers it
+// named, so the shared sync lookup and a send whose config read fails see it.
+const goModelCache = makeModelCache({ fileName: 'opencode-go-oauth-models.json', ttlMs: 24 * 60 * 60_000, version: 1 });
+
+const isPlainObject = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+const positive = (value) => (Number.isFinite(Number(value)) && Number(value) > 0 ? Number(value) : null);
+const finite = (value) => (value !== null && value !== '' && Number.isFinite(Number(value)) ? Number(value) : null);
+
+function stringHeaders(value) {
+  if (!isPlainObject(value)) return {};
+  return Object.fromEntries(Object.entries(value).filter(([, v]) => typeof v === 'string'));
+}
+
+// The untiered price (or the first one) in USD per million tokens.
+function costFields(cost) {
+  const list = Array.isArray(cost) ? cost : [cost];
+  const base = list.find((entry) => isPlainObject(entry) && !entry.tier) || list.find(isPlainObject);
+  if (!base) return {};
+  const fields = {
+    inputCostPerM: finite(base.input),
+    outputCostPerM: finite(base.output),
+    cacheReadCostPerM: finite(base.cache?.read),
+    cacheWriteCostPerM: finite(base.cache?.write),
+  };
+  return Object.fromEntries(Object.entries(fields).filter(([, v]) => v !== null));
+}
+
+function reasoningFields(reasoning) {
+  if (!isPlainObject(reasoning) || typeof reasoning.supported !== 'boolean') return {};
+  if (!reasoning.supported) return { supportsReasoning: false, reasoningOptions: [], reasoningLevels: [] };
+  const levels = Array.isArray(reasoning.effort) ? reasoning.effort.filter((v) => typeof v === 'string' && v) : [];
+  return {
+    supportsReasoning: true,
+    ...(levels.length ? { reasoningOptions: [{ type: 'effort', values: levels }], reasoningLevels: levels } : {}),
+  };
+}
+
+function catalogRow(id, model, providerPackage) {
+  const name = typeof model.name === 'string' && model.name.trim() ? model.name.trim() : id;
+  const wirePackage = typeof model.package === 'string' ? model.package : providerPackage;
+  const wire = Object.hasOwn(WIRE_API_BY_NPM, wirePackage || '') ? WIRE_API_BY_NPM[wirePackage] : null;
+  const baseURL = typeof model.settings?.baseURL === 'string' ? model.settings.baseURL : '';
+  const headers = stringHeaders(model.headers);
+  return {
+    id,
+    provider: PROVIDER_ID,
+    name,
+    ...(positive(model.limit?.context) ? { contextWindow: positive(model.limit.context) } : {}),
+    ...(positive(model.limit?.output) ? { outputTokens: positive(model.limit.output) } : {}),
+    ...reasoningFields(model.capabilities?.reasoning),
+    ...costFields(model.cost),
+    ...(wire ? { wire } : {}),
+    ...(baseURL ? { baseURL } : {}),
+    ...(Object.keys(headers).length ? { headers } : {}),
+  };
+}
+
+/**
+ * The Go provider of a remote config response: `{ baseURL, headers, models }`
+ * with one catalog row per enabled model.
+ */
+export function goConfigFromResponse(json) {
+  const entry = json?.providers?.[CONFIG_PROVIDER_KEY];
+  if (!isPlainObject(entry)) {
+    throw openCodeGoError(`[${PROVIDER_ID}] the OpenCode organization config has no OpenCode Go provider`, {
+      kind: 'catalog',
+    });
+  }
+  const providerPackage = typeof entry.package === 'string' ? entry.package : '';
+  const models = Object.entries(isPlainObject(entry.models) ? entry.models : {})
+    .filter(([id, model]) => id && isPlainObject(model) && model.disabled !== true)
+    .map(([id, model]) => catalogRow(id, model, providerPackage));
+  return {
+    baseURL:
+      typeof entry.settings?.baseURL === 'string' && entry.settings.baseURL
+        ? entry.settings.baseURL
+        : FALLBACK_BASE_URL,
+    headers: stringHeaders(entry.headers),
+    models,
+  };
+}
+
+// The model list rows (the request routing fields stay in the cache).
+function listRow({ wire: _wire, baseURL: _baseURL, headers: _headers, ...row }) {
+  return row;
+}
+
+const isUnauthorized = (err) => Number(err?.status || err?.httpStatus) === 401;
+const emittedOutput = (err) =>
+  err?.liveTextEmitted === true || err?.emittedToolCall === true || err?.unsafeToRetry === true;
+
+// The gateway engines on a fixed credential: the compat 401 handler re-reads
+// the OpenCode Go API key from config, which must never reach this endpoint.
+const pinCredential = (engine) => {
+  engine.reloadApiKey = () => {};
+  return engine;
+};
+
+class OpenCodeGoOAuthEngine extends OpenCodeGoProvider {
+  constructor(config) {
+    super(config);
+    pinCredential(this.openai);
+    pinCredential(this.anthropic);
+  }
+
+  async _geminiEngine() {
+    return pinCredential(await super._geminiEngine());
+  }
+}
+
+export class OpenCodeGoOAuthProvider {
+  // No document block on this wire: a PDF is lowered to text before the request is built.
+  nativePdf = false;
+  static inputExcludesCache = false;
+  name = PROVIDER_ID;
+  config;
+  tokens = null;
+  _remote = null;
+  _engines = new Map();
+
+  constructor(config) {
+    this.config = config || {};
+    this.tokens = loadTokens();
+  }
+
+  async ensureAuth({ forceRefresh = false } = {}) {
+    this.tokens = await ensureFreshTokens({ force: forceRefresh, fetchFn: this.config.fetchImpl });
+    return this.tokens;
+  }
+
+  // The remote config for this credential, re-read after CONFIG_TTL_MS; only
+  // a read with the still-signed-in account publishes the catalog.
+  async _remoteConfig(tokens, { force = false } = {}) {
+    const key = `${tokens.account_id}\0${tokens.org_id}`;
+    if (!force && this._remote?.key === key && Date.now() - this._remote.fetchedAt < CONFIG_TTL_MS) return this._remote;
+    const publish = goModelCache.beginSave(() => {
+      const current = loadTokens();
+      return current?.account_id === tokens.account_id && current?.org_id === tokens.org_id;
+    });
+    const remote = goConfigFromResponse(
+      await consoleGetJson(CONFIG_URL, tokens, { fetchFn: this.config.fetchImpl, refresh: true })
+    );
+    publish(remote.models, {
+      baseURL: remote.baseURL,
+      headers: remote.headers,
+      accountId: tokens.account_id,
+      orgId: tokens.org_id,
+    });
+    this._remote = { key, fetchedAt: Date.now(), ...remote, byId: new Map(remote.models.map((row) => [row.id, row])) };
+    return this._remote;
+  }
+
+  // A send keeps working on the last catalog of the same account and
+  // organization when the config cannot be read right now (its headers route
+  // to that organization); a rejected credential is never papered over.
+  async _sendConfig(tokens) {
+    try {
+      return await this._remoteConfig(tokens);
+    } catch (err) {
+      if (isUnauthorized(err) || err?.reauthRequired) throw err;
+      const entry = goModelCache.loadEntrySync({ allowStale: true });
+      if (!entry || entry.accountId !== tokens.account_id || entry.orgId !== tokens.org_id) throw err;
+      return {
+        baseURL: entry.baseURL || FALLBACK_BASE_URL,
+        headers: stringHeaders(entry.headers),
+        models: entry.models,
+        byId: new Map(entry.models.map((row) => [row.id, row])),
+      };
+    }
+  }
+
+  // The configured wire per model; the user's own modelWires win.
+  _modelWires(models) {
+    const wires = Object.fromEntries(models.filter((row) => row.wire).map((row) => [row.id, row.wire]));
+    return { ...wires, ...(this.config.modelWires || {}) };
+  }
+
+  _engine(tokens, remote, row) {
+    const baseURL = row?.baseURL || remote.baseURL;
+    const headers = { ...(this.config.extraHeaders || {}), ...remote.headers, ...(row?.headers || {}) };
+    const modelWires = this._modelWires(remote.models);
+    const signature = JSON.stringify([baseURL, headers, modelWires]);
+    const cached = this._engines.get(signature);
+    if (cached && cached.token === tokens.access_token) return cached.engine;
+    const { fetchImpl, apiKeyEnv: _env, ...config } = this.config;
+    const engine = new OpenCodeGoOAuthEngine({
+      ...config,
+      apiKey: tokens.access_token,
+      baseURL,
+      extraHeaders: headers,
+      modelWires,
+      // Explicit nulls keep OPENAI_ORG_ID / OPENAI_PROJECT_ID out of the requests.
+      clientOptions: { organization: null, project: null, ...(fetchImpl ? { fetch: fetchImpl } : {}) },
+    });
+    this._engines.set(signature, { token: tokens.access_token, engine });
+    return engine;
+  }
+
+  _scrub(err) {
+    if (err && typeof err.message === 'string' && this.tokens) {
+      err.message = scrubOAuthSecrets(err.message, [this.tokens.access_token, this.tokens.refresh_token]);
+    }
+    return err;
+  }
+
+  async send(messages, model, tools, sendOpts) {
+    const attempt = async (forceRefresh) => {
+      const tokens = await this.ensureAuth({ forceRefresh });
+      const remote = await this._sendConfig(tokens);
+      return this._engine(tokens, remote, remote.byId.get(model)).send(messages, model, tools, sendOpts);
+    };
+    try {
+      return await attempt(false);
+    } catch (err) {
+      if (!isUnauthorized(err) || err?.reauthRequired || emittedOutput(err)) throw this._scrub(err);
+    }
+    // The stored expiry cannot see a revoked session: refresh once and ask again.
+    try {
+      return await attempt(true);
+    } catch (err) {
+      if (isUnauthorized(err) && !err?.reauthRequired) throw openCodeGoReauthError('inference 401');
+      throw this._scrub(err);
+    }
+  }
+
+  resolveWireRoute(model, ctx = {}) {
+    const models = this._remote?.models || goModelCache.loadSync({ allowStale: true }) || [];
+    return resolveOpenCodeGoWireRoute(model, { ...ctx, override: this._modelWires(models)[model] ?? null });
+  }
+
+  async listModels() {
+    try {
+      const tokens = await this.ensureAuth();
+      const remote = await this._remoteConfig(tokens, { force: true });
+      return remote.models.map((row) => ({ ...this.getCachedModelInfo(row.id), ...listRow(row) }));
+    } catch (err) {
+      throw this._scrub(err);
+    }
+  }
+
+  getCachedModelInfo(model) {
+    const rows = this._remote?.models || goModelCache.loadSync({ allowStale: true }) || [];
+    const row = rows.find((candidate) => candidate?.id === model);
+    const meta = getModelMetadataSync(model, PROVIDER_ID);
+    if (!row && !meta) return null;
+    return { ...(meta || {}), ...(row ? listRow(row) : {}), id: model, provider: PROVIDER_ID };
+  }
+
+  /** Go 5-hour / weekly / monthly meters of this account's organization. */
+  async getUsageSnapshot() {
+    const tokens = await this.ensureAuth();
+    return await fetchOpenCodeGoOAuthUsageSnapshot(tokens, { fetchFn: this.config.fetchImpl });
+  }
+
+  async isAvailable() {
+    return loadTokens() !== null;
+  }
+}

package/src/runtime/agent/orchestrator/providers/opencode-go-usage.mjs

@@ -1,28 +1,15 @@
-import { join } from 'node:path';
-import { updateJsonAtomicSync } from '../../../shared/atomic-file.mjs';
-import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
-import { getAgentApiKey, getOpenCodeGoConsoleKey } from '../../../shared/config.mjs';
 import { round, cleanString as clean } from './lib/usage-primitives.mjs';
-import { JsonMemoryCache } from './lib/json-memory-cache.mjs';
-import { recordQuotaReadings } from './lib/quota-readings.mjs';
+import { STATUS_URL, consoleHeaders, withConsoleTokenRetry } from './opencode-go-oauth-tokens.mjs';
 
-const CACHE_FILE = 'opencode-go-usage-cache.json';
-const LIVE_TTL_MS = 5 * 60_000;
-const STALE_TTL_MS = 60 * 60_000;
 const FETCH_TIMEOUT_MS = 6500;
-// The console replaced its server-rendered page (usage inlined in the HTML) with
-// a SPA over this REST API, so scraping `/workspace/{id}/go` now yields an empty
-// shell. `GET /api/go/status` answers a service-account key that carries the
-// `all` permission and rejects `inference-only` keys with 403. The key itself
-// resolves the workspace, so no workspace id or `x-org-id` header is needed.
-const BASE_URL = 'https://opencode.ai/console';
+// `GET /api/go/status` answers an OpenCode Console OAuth token; the token
+// names its organization through `x-org-id`.
 const USER_AGENT =
   'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143 Safari/537.36';
 // Meters report micro-cents as strings: "1200000000" is the $12 five-hour cap.
 // Limits come from the response, so a plan change needs no code change.
 const MICRO_CENTS_PER_USD = 1e8;
 const METER_LABELS = Object.freeze({ fiveHour: '5H', week: '7D', month: 'M' });
-const diskJsonCache = new JsonMemoryCache();
 
 // Local unguarded `num`: this module intentionally coerces '' to 0 via
 // Number(''), unlike the guarded shared num() in lib/usage-primitives.mjs.
@@ -32,61 +19,18 @@ function num(value, fallback = null) {
   return Number.isFinite(n) ? n : fallback;
 }
 
-function cachePath() {
-  return join(resolvePluginData(), CACHE_FILE);
-}
-
-// Synchronous atomic+lock write (updateJsonAtomicSync) instead of the prior
-// fire-and-forget fsp.writeFile: this cache is single-entry (one snapshot
-// per file, no cross-process merge), so the lock protects against a torn
-// write racing readers, not a lost-update merge. Only one write happens
-// per successful fetch (TTL-gated, at most once per LIVE_TTL_MS), so the
-// switch off async has no meaningful latency impact on the request path.
-function writeJson(file, value) {
-  let next = null;
-  try {
-    next = updateJsonAtomicSync(file, () => value, { lock: true, fsyncDir: true, timeoutMs: 1000 }); // best-effort cache write: short lock timeout, don't block on contention
-  } catch {}
-  if (next) diskJsonCache.remember(file, next);
-}
-
-function freshSnapshot(snapshot, ttlMs) {
-  const cachedAt = num(snapshot?.cachedAt, 0);
-  if (!cachedAt || Date.now() - cachedAt > ttlMs) return null;
-  return Array.isArray(snapshot?.quotaWindows) && snapshot.quotaWindows.length ? snapshot : null;
-}
-
-function isConsoleKey(value) {
-  return /^(?:oc_sk_|sk-)/.test(String(value || ''));
-}
-
-// Usage auth is a console API key holding the `all` permission; the inference
-// key is the fallback when one key serves both roles. A stored value that is
-// not key-shaped predates the API migration, so it counts as "not configured"
-// and the UI asks for a key instead of surfacing an opaque 401.
-function consoleApiKey() {
-  const stored = clean(getOpenCodeGoConsoleKey());
-  if (isConsoleKey(stored)) return stored;
-  const inferenceKey = clean(getAgentApiKey('opencode-go'));
-  return isConsoleKey(inferenceKey) ? inferenceKey : null;
-}
-
+// `status` lets the usage path refresh the token on a 401.
 function statusError(status) {
   if (status === 401) {
-    const err = new Error('OpenCode console API key was rejected');
-    err.code = 'OPENCODE_GO_USAGE_AUTH_FAILED';
-    return err;
-  }
-  if (status === 403) {
-    const err = new Error(
-      'OpenCode console API key lacks permission: subscription usage needs an "all" key, not an inference-only key'
-    );
-    err.code = 'OPENCODE_GO_USAGE_FORBIDDEN';
-    return err;
+    return Object.assign(new Error('OpenCode console credential was rejected'), {
+      code: 'OPENCODE_GO_USAGE_AUTH_FAILED',
+      status,
+    });
   }
-  const err = new Error(`OpenCode Go usage fetch failed (${status})`);
-  err.code = 'OPENCODE_GO_USAGE_FETCH_FAILED';
-  return err;
+  return Object.assign(new Error(`OpenCode Go usage fetch failed (${status})`), {
+    code: 'OPENCODE_GO_USAGE_FETCH_FAILED',
+    status,
+  });
 }
 
 function usdFromMicroCents(value) {
@@ -125,37 +69,15 @@ function snapshotFromStatus(status) {
   return { provider: 'opencode-go', source: 'opencode-go-console', quotaWindows };
 }
 
-export function readCachedOpenCodeGoUsageSnapshot({ allowStale = true } = {}) {
-  const raw = diskJsonCache.read(cachePath());
-  const snapshot = raw?.snapshot || raw;
-  return freshSnapshot(snapshot, allowStale ? STALE_TTL_MS : LIVE_TTL_MS);
-}
-
-export function openCodeGoUsageConfigStatus() {
-  return { ready: Boolean(consoleApiKey()) };
-}
-
-export async function fetchOpenCodeGoUsageSnapshot(_config = {}, { force = false } = {}) {
-  if (!force) {
-    const fresh = readCachedOpenCodeGoUsageSnapshot({ allowStale: false });
-    if (fresh) return fresh;
-  }
-  const apiKey = consoleApiKey();
-  if (!apiKey) {
-    const err = new Error('OpenCode Go usage requires an OpenCode console API key');
-    err.code = 'OPENCODE_GO_USAGE_AUTH_REQUIRED';
-    throw err;
-  }
+// One `/api/go/status` read. `headers` carry the OAuth token plus `x-org-id`.
+async function requestGoStatus(headers, fetchFn = fetch) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
   try {
-    const res = await fetch(`${BASE_URL}/api/go/status`, {
+    const res = await fetchFn(STATUS_URL, {
       signal: controller.signal,
-      headers: {
-        Accept: 'application/json',
-        Authorization: `Bearer ${apiKey}`,
-        'User-Agent': USER_AGENT,
-      },
+      redirect: 'error',
+      headers: { Accept: 'application/json', 'User-Agent': USER_AGENT, ...headers },
     });
     if (!res.ok) throw statusError(res.status);
     const parsed = snapshotFromStatus(await res.json().catch(() => null));
@@ -164,12 +86,23 @@ export async function fetchOpenCodeGoUsageSnapshot(_config = {}, { force = false
       err.code = 'OPENCODE_GO_USAGE_PARSE_FAILED';
       throw err;
     }
-    const snapshot = { ...parsed, cachedAt: Date.now() };
-    writeJson(cachePath(), { version: 1, updatedAt: Date.now(), snapshot });
-    // One console key serves the whole subscription: a single account.
-    void recordQuotaReadings('opencode-go', 'default', snapshot);
-    return snapshot;
+    return parsed;
   } finally {
     clearTimeout(timer);
   }
 }
+
+/** Go meters for one OpenCode Go OAuth account (its token and organization). */
+export async function fetchOpenCodeGoOAuthUsageSnapshot(tokens, { fetchFn } = {}) {
+  const parsed = await withConsoleTokenRetry(tokens, (current) => requestGoStatus(consoleHeaders(current), fetchFn), {
+    fetchFn,
+  });
+  return {
+    ...parsed,
+    provider: 'opencode-go-oauth',
+    model: null,
+    fetchedAt: Date.now(),
+    ...(tokens.email ? { email: tokens.email } : {}),
+    ...(tokens.account_id ? { accountId: tokens.account_id } : {}),
+  };
+}

package/src/runtime/agent/orchestrator/providers/opencode-go.mjs

@@ -1,11 +1,21 @@
 import { randomUUID } from 'node:crypto';
 import { AnthropicProvider } from './anthropic.mjs';
-import { OpenAICompatProvider, OPENAI_COMPAT_PRESETS } from './openai-compat.mjs';
+import { OpenAICompatProvider } from './openai-compat.mjs';
 import { getModelMetadataSync, getModelsDevRowSync } from './model-catalog.mjs';
-import { toInclusiveUsage, withInclusiveUsage } from './lib/inclusive-usage.mjs';
+import { withInclusiveUsage } from './lib/inclusive-usage.mjs';
 import { providerOffersWire, resolveWireRoute, sendOnRoute } from './wire-route.mjs';
 import { gatewayMessagesOpts } from './wire-gateway.mjs';
 
+// The OpenCode Go gateway engines. Not a registered provider: the
+// `opencode-go-oauth` provider (opencode-go-oauth.mjs) runs its requests here
+// on the account's OAuth access token. `opencode-go` stays the engines' internal
+// wire/catalog id.
+const GO_GATEWAY_PRESET = Object.freeze({
+  baseURL: 'https://opencode.ai/inference/go/v1',
+  // The gateway expects an application User-Agent (not the SDK default).
+  extraHeaders: Object.freeze({ 'User-Agent': 'mixdog' }),
+});
+
 // The Go Anthropic route: the shared request builder gets the model's output
 // ceiling (models.dev limit) through the gateway options.
 class OpenCodeGoMessagesEngine extends AnthropicProvider {
@@ -21,7 +31,7 @@ class OpenCodeGoMessagesEngine extends AnthropicProvider {
 // is the authoritative wire selector; wire-route.mjs holds the cold-catalog
 // prefix fallback. `@ai-sdk/google` names the Gemini generateContent wire
 // (opencode-go-gemini.mjs).
-const WIRE_API_BY_NPM = Object.freeze({
+export const WIRE_API_BY_NPM = Object.freeze({
   '@ai-sdk/openai': 'responses',
   '@ai-sdk/anthropic': 'messages',
   '@ai-sdk/openai-compatible': 'chat',
@@ -33,7 +43,7 @@ function openCodeGoCatalogWire(model) {
   return typeof npm === 'string' && Object.hasOwn(WIRE_API_BY_NPM, npm) ? WIRE_API_BY_NPM[npm] : null;
 }
 
-function resolveOpenCodeGoWireRoute(model, ctx = {}) {
+export function resolveOpenCodeGoWireRoute(model, ctx = {}) {
   const catalogWire = openCodeGoCatalogWire(model);
   // Each Go model answers on the one wire the catalog names: it narrows the
   // offered endpoints, so an override cannot pick a wire the model lacks.
@@ -51,8 +61,7 @@ export function isAnthropicGoModel(model) {
 }
 
 export function resolveOpenCodeGoBaseURLs(configuredBaseURL) {
-  const presetBase = OPENAI_COMPAT_PRESETS['opencode-go'].baseURL;
-  const openai = String(configuredBaseURL || presetBase).replace(/\/+$/, '');
+  const openai = String(configuredBaseURL || GO_GATEWAY_PRESET.baseURL).replace(/\/+$/, '');
   // Anthropic's SDK appends `/v1/messages` itself. Supplying the OpenAI base
   // (`.../v1`) would therefore produce the invalid `.../v1/v1/messages`.
   const anthropic = openai.replace(/\/v1$/i, '');
@@ -67,9 +76,6 @@ export function openCodeGoEndpointForModel(model, configuredBaseURL) {
   return `${bases.openai}/chat/completions`;
 }
 
-// The Messages route reports usage in the provider's inclusive convention.
-export const toInclusiveOpenCodeGoUsage = toInclusiveUsage;
-
 function opencodeGoContextWindow(modelId, current = 0) {
   const native = Number(current);
   if (Number.isFinite(native) && native > 0) return native;
@@ -100,9 +106,12 @@ export class OpenCodeGoProvider {
     // lane. The delegated transports are intentionally not independently
     // wrapped, so all model-family routes share this one 64-wide account.
     this.config = config;
-    const preset = OPENAI_COMPAT_PRESETS['opencode-go'];
-    const bases = resolveOpenCodeGoBaseURLs(config.baseURL || preset.baseURL);
-    this.openai = new OpenAICompatProvider('opencode-go', { ...config, baseURL: bases.openai });
+    const bases = resolveOpenCodeGoBaseURLs(config.baseURL);
+    this.openai = new OpenAICompatProvider('opencode-go', {
+      ...config,
+      baseURL: bases.openai,
+      extraHeaders: { ...GO_GATEWAY_PRESET.extraHeaders, ...(config.extraHeaders || {}) },
+    });
     this.anthropic = new OpenCodeGoMessagesEngine({
       ...config,
       name: 'opencode-go',
@@ -110,7 +119,7 @@ export class OpenCodeGoProvider {
       disableBetaHeaders: true,
       // The preset's identifying headers (User-Agent) ride the Messages wire
       // too; the user's own headers win.
-      extraHeaders: { ...(preset.extraHeaders || {}), ...(config.extraHeaders || {}) },
+      extraHeaders: { ...GO_GATEWAY_PRESET.extraHeaders, ...(config.extraHeaders || {}) },
       modelMaxOutputTokens: (model) => this.getCachedModelInfo(model)?.outputTokens,
     });
     // The Anthropic route answers for this provider: PDFs lower to text.
@@ -163,7 +172,7 @@ export class OpenCodeGoProvider {
         ...this.config,
         baseURL: this.openai.baseURL,
         extraHeaders: {
-          ...(OPENAI_COMPAT_PRESETS['opencode-go'].extraHeaders || {}),
+          ...GO_GATEWAY_PRESET.extraHeaders,
           ...(this.config.extraHeaders || {}),
         },
       });