dsh-opencode-go 0.1.19 → 0.1.21

package/lib/index.js

@@ -988,7 +988,7 @@ function diagnosticURL(raw) {
   url.hash = "";
   return url.href;
 }
-async function fetchJsonResponse(url, init, maxBytes, encoding = "identity") {
+async function fetchJsonResponse(url, init, maxBytes, encoding = "identity", fetcher = globalThis.fetch) {
   if ((init.method ?? "GET").toUpperCase() !== "GET") throw new TypeError("JSON requests must use GET");
   const headers = new Headers(init.headers);
   headers.set("accept-encoding", encoding);
@@ -996,7 +996,7 @@ async function fetchJsonResponse(url, init, maxBytes, encoding = "identity") {
   for (let attempt = 0; ; attempt += 1) {
     init.signal?.throwIfAborted();
     try {
-      const response = await fetch(url, options);
+      const response = await fetcher(url, options);
       if (!response.ok) {
         await response.body?.cancel().catch(() => {
         });
@@ -1167,7 +1167,7 @@ function readLiveModelIds(body) {
   }
   return [...new Set(ids)];
 }
-async function fetchLiveModelIds(baseURL) {
+async function fetchLiveModelIds(baseURL, fetcher) {
   const url = `${baseURL.replace(/\/+$/, "")}/models`;
   const endpoint = diagnosticURL(url);
   let result;
@@ -1177,7 +1177,7 @@ async function fetchLiveModelIds(baseURL) {
       cache: "no-cache",
       headers: { ...attributionHeaders(), accept: "application/json" },
       signal: AbortSignal.timeout(MODELS_FETCH_TIMEOUT_MS)
-    }, MODEL_LISTING_MAX_BYTES);
+    }, MODEL_LISTING_MAX_BYTES, "identity", fetcher);
   } catch (error) {
     const detail = error instanceof SyntaxError ? "invalid JSON response" : error instanceof RangeError ? `response exceeds the ${MODEL_LISTING_MAX_BYTES} byte limit` : transportFailure(error);
     const action = error instanceof SyntaxError || error instanceof RangeError ? "read" : "reach";
@@ -1213,12 +1213,13 @@ function buildProvider(baseURL, models) {
 }
 var OpencodeGoCatalog = class {
   constructor(baseURL, refreshMs, onFallback, onOmitted, onRefresh = () => {
-  }) {
+  }, fetcher) {
     this.baseURL = baseURL;
     this.refreshMs = refreshMs;
     this.onFallback = onFallback;
     this.onOmitted = onOmitted;
     this.onRefresh = onRefresh;
+    this.fetcher = fetcher;
   }
   served;
   pending;
@@ -1260,7 +1261,7 @@ var OpencodeGoCatalog = class {
   }
   startRefresh(force) {
     const builtin = builtinModels(this.baseURL);
-    const listing = settled(fetchLiveModelIds(this.baseURL).then((ids) => ({ ids, updatedAtMs: Date.now() })));
+    const listing = settled(fetchLiveModelIds(this.baseURL, this.fetcher).then((ids) => ({ ids, updatedAtMs: Date.now() })));
     const restored = this.metadata;
     if (!force && this.served === void 0 && restored !== void 0) {
       const status = { metadataLive: false, metadataUpdatedAtMs: this.metadataUpdatedAtMs };
@@ -1304,7 +1305,7 @@ var OpencodeGoCatalog = class {
       },
       cache: "no-cache",
       signal: AbortSignal.timeout(METADATA_FETCH_TIMEOUT_MS)
-    }, MODEL_METADATA_MAX_BYTES, "gzip");
+    }, MODEL_METADATA_MAX_BYTES, "gzip", this.fetcher);
     if (response.status === 304 && this.metadata !== void 0) {
       this.metadataUpdatedAtMs = Date.now();
       this.metadataETag = metadataETag(response.headers.get("etag")) ?? this.metadataETag;
@@ -1464,6 +1465,35 @@ import z from "@deepseek-ai/schemastery";
 var USAGE_DISPLAY_MODES = ["auto", "always", "off"];
 var DEFAULT_USAGE_DISPLAY = "auto";
 
+// src/accounts.ts
+var MAX_ACCOUNTS = 20;
+var DEFAULT_ACCOUNT_REF = "OPENCODE_API_KEY";
+function accountRefOf(settings) {
+  return settings.apiKeyEnv || DEFAULT_ACCOUNT_REF;
+}
+function accountsOf(settings) {
+  const ref = accountRefOf(settings);
+  if (settings.accounts?.length === 0) return [];
+  const accounts = settings.accounts ?? [];
+  return accounts.some((account) => account.apiKeyEnv === ref) ? accounts : [
+    { id: `legacy:${ref}`, name: "", apiKeyEnv: ref },
+    ...accounts
+  ];
+}
+function assertAccounts(accounts, selectedRef) {
+  if (accounts == null) return;
+  if (!Array.isArray(accounts) || accounts.length > MAX_ACCOUNTS || accounts.length === MAX_ACCOUNTS && selectedRef && !accounts.some((account) => account.apiKeyEnv === selectedRef)) {
+    throw new Error(`OpenCode Go supports at most ${MAX_ACCOUNTS} accounts, including the selected reference`);
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const refs = /* @__PURE__ */ new Set();
+  for (const account of accounts) {
+    if (!account || typeof account.id !== "string" || !account.id || account.id.length > 128 || account.id.startsWith("legacy:") && account.id !== `legacy:${account.apiKeyEnv}` || typeof account.name !== "string" || !account.name.trim() && account.id !== `legacy:${account.apiKeyEnv}` || account.name.length > 80 || typeof account.apiKeyEnv !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(account.apiKeyEnv) || ids.has(account.id) || refs.has(account.apiKeyEnv)) throw new Error("Invalid or duplicate OpenCode Go account");
+    ids.add(account.id);
+    refs.add(account.apiKeyEnv);
+  }
+}
+
 // src/config.ts
 var DEFAULT_API_KEY_ENV = "OPENCODE_API_KEY";
 var DEFAULT_REFRESH_MINUTES = 60;
@@ -1473,7 +1503,14 @@ var fields = {
   usageDisplay: z.union(USAGE_DISPLAY_MODES.map((mode) => z.const(mode))).default(DEFAULT_USAGE_DISPLAY),
   modelVisibility: z.dict(z.boolean().required()).default({}),
   apiKeyEnv: z.string().role("credential-ref").default(DEFAULT_API_KEY_ENV),
+  accounts: z.union([z.const(null), z.array(z.object({
+    id: z.string().required(),
+    name: z.string().required(),
+    apiKeyEnv: z.string().role("credential-ref").required()
+  })).max(MAX_ACCOUNTS)]).default(null),
+  autoSwitch: z.boolean().default(false),
   baseURL: z.string().default(DEFAULT_BASE_URL),
+  proxyURL: z.string().default(""),
   refreshMinutes: z.number().step(1).min(1).max(7 * 24 * 60).default(DEFAULT_REFRESH_MINUTES),
   streamIdleTimeoutMs: z.number().min(Number.MIN_VALUE).max(MAX_TIMER_DELAY_MS).default(DEFAULT_STREAM_IDLE_TIMEOUT_MS),
   maxImages: z.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER),
@@ -1511,7 +1548,87 @@ function assertBaseURL(raw) {
   return url.toString().replace(/\/+$/, "");
 }
 
+// src/proxy-url.ts
+function assertProxyURL(raw) {
+  const value = raw?.trim() ?? "";
+  if (!value) return "";
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("OpenCode Go: proxy address must be a valid URL");
+  }
+  if (!["http:", "https:", "socks5:"].includes(url.protocol)) {
+    throw new Error("OpenCode Go: proxy address must use http://, https:// or socks5://");
+  }
+  if (!url.hostname || url.port === "0" || url.pathname !== "" && url.pathname !== "/" || url.search || url.hash) {
+    throw new Error("OpenCode Go: proxy address must contain a host and optional port, without a path, query or fragment");
+  }
+  try {
+    decodeURIComponent(url.username);
+    decodeURIComponent(url.password);
+  } catch {
+    throw new Error("OpenCode Go: proxy credentials contain invalid URL encoding");
+  }
+  return url.href;
+}
+
+// src/proxy.ts
+import { ProxyAgent, Socks5ProxyAgent } from "undici";
+var ProxyTransport = class {
+  current;
+  retired = /* @__PURE__ */ new Set();
+  disposed = false;
+  forProxy(raw) {
+    const address = assertProxyURL(raw);
+    if (!address) {
+      this.retire();
+      return void 0;
+    }
+    return (input, init) => {
+      if (this.disposed) return Promise.reject(new Error("OpenCode Go proxy transport is disposed"));
+      if (this.current?.address !== address) {
+        const url = new URL(address);
+        const dispatcher = url.protocol === "socks5:" ? new Socks5ProxyAgent(url) : new ProxyAgent(address);
+        this.retire();
+        this.current = { address, dispatcher };
+      }
+      const options = { ...init, dispatcher: this.current.dispatcher };
+      return globalThis.fetch(input, options);
+    };
+  }
+  /** Close replaced pools after their in-flight response bodies have finished. */
+  retire() {
+    if (!this.current) return;
+    const { dispatcher } = this.current;
+    this.current = void 0;
+    this.retired.add(dispatcher);
+    void dispatcher.close().catch(() => dispatcher.destroy()).catch(() => {
+    }).finally(() => {
+      this.retired.delete(dispatcher);
+    });
+  }
+  /** Unloading the mount cancels remaining requests and releases every pool. */
+  async dispose() {
+    this.disposed = true;
+    const dispatchers = [...this.retired, ...this.current ? [this.current.dispatcher] : []];
+    this.current = void 0;
+    this.retired.clear();
+    await Promise.all(dispatchers.map((dispatcher) => dispatcher.destroy().catch(() => {
+    })));
+  }
+};
+
 // src/adapter.ts
+function accountFailureReason(failure) {
+  if (failure.code === "QUOTA") return "quota";
+  if (failure.code === "MISSING_CREDENTIAL" || failure.code === "INVALID_CREDENTIAL" || failure.code === "AUTH" && (/\b401\b/.test(failure.message) || /invalid[ _-]?(?:api[ _-]?)?key|incorrect[ _-]?(?:api[ _-]?)?key|expired[ _-]?(?:api[ _-]?)?key/i.test(failure.message))) return "credential";
+  return void 0;
+}
+var REJECTED_KEY_TTL_MS = 5 * 6e4;
+function isGatewayKeyRejection(failure) {
+  return failure.code === "INVALID_CREDENTIAL" || failure.code === "AUTH";
+}
 function withModelLimit(model, limits) {
   const limit = limits[model.id];
   if (limit == null) return model;
@@ -1528,6 +1645,7 @@ var OpencodeGoAdapter = class extends LlmAdapter {
   constructor(options) {
     super();
     this.options = options;
+    this.transport = options.transport ?? new ProxyTransport();
   }
   /**
    * One catalog instance per endpoint/refresh pair. A settings write that
@@ -1536,6 +1654,12 @@ var OpencodeGoAdapter = class extends LlmAdapter {
    * for the whole refresh interval.
    */
   catalogCache;
+  transport;
+  /** Per-reference rejection deadlines, isolated by the gateway that rejected it. */
+  rejectedKeys = /* @__PURE__ */ new Map();
+  dispose() {
+    return this.transport.dispose();
+  }
   /**
    * The catalog resolver for one configuration, rebuilding on the facts it
    * owns. Public for the plugin's discovery registration, which resolves the
@@ -1544,7 +1668,7 @@ var OpencodeGoAdapter = class extends LlmAdapter {
    * @returns the resolver caching catalog values, independent of deployment limits.
    */
   catalogOf(config) {
-    const key = `${config.baseURL}|${String(config.refreshMinutes)}`;
+    const key = JSON.stringify([config.baseURL, config.refreshMinutes, assertProxyURL(config.proxyURL)]);
     if (this.catalogCache?.key !== key) {
       const catalog = new OpencodeGoCatalog(
         assertBaseURL(config.baseURL),
@@ -1557,7 +1681,8 @@ var OpencodeGoAdapter = class extends LlmAdapter {
         }),
         () => {
           if (this.catalogCache?.catalog === catalog) this.options.onCatalogRefresh?.();
-        }
+        },
+        this.transport.forProxy(config.proxyURL)
       );
       this.catalogCache = { key, catalog };
     }
@@ -1649,6 +1774,93 @@ var OpencodeGoAdapter = class extends LlmAdapter {
     yield* this.streamWithSnapshot(options, snapshot);
   }
   async *streamWithSnapshot(options, snapshot) {
+    const accounts = accountsOf(snapshot.config);
+    if (accounts.length === 0) throw new LlmError6("OpenCode Go has no accounts", "MISSING_CREDENTIAL");
+    const ordered = snapshot.config.autoSwitch ? [.../* @__PURE__ */ new Set([snapshot.config.apiKeyEnv, ...accounts.map((account) => account.apiKeyEnv)])] : [snapshot.config.apiKeyEnv];
+    const now = Date.now();
+    const gateway = assertBaseURL(snapshot.config.baseURL);
+    const usable = ordered.filter((ref) => {
+      const rejected = this.rejectedKeys.get(ref);
+      const until = rejected?.get(gateway);
+      if (until === void 0) return true;
+      if (now >= until) {
+        rejected.delete(gateway);
+        if (rejected.size === 0) this.rejectedKeys.delete(ref);
+        return true;
+      }
+      return false;
+    });
+    const refs = usable.length > 0 ? usable : ordered;
+    const skippedRef = ordered.find((ref) => !refs.includes(ref));
+    let switchReason;
+    let failedRef;
+    for (let attempt = 0; attempt < refs.length; attempt++) {
+      let emitted = false;
+      let usage;
+      let retry = false;
+      const announce = () => {
+        if (emitted) return;
+        const serving = refs[attempt];
+        if (serving === snapshot.config.apiKeyEnv) this.options.onAccountSwitch?.(void 0, snapshot.config);
+        else this.options.onAccountSwitch?.({
+          // The notice names the account the journey left: the first one that
+          // failed this request, else the first one skipped for a remembered
+          // rejection.
+          fromRef: failedRef ?? skippedRef ?? snapshot.config.apiKeyEnv,
+          toRef: serving,
+          reason: switchReason ?? "credential",
+          at: Date.now()
+        }, snapshot.config);
+      };
+      try {
+        for await (const chunk of this.streamAttempt(options, {
+          ...snapshot,
+          config: { ...snapshot.config, apiKeyEnv: refs[attempt] }
+        })) {
+          if (chunk.type === "usage") {
+            usage = chunk;
+            continue;
+          }
+          if (chunk.type === "finish") {
+            const failure = chunk.reason.kind === "error" ? chunk.reason.failure : void 0;
+            const reason = failure === void 0 ? void 0 : accountFailureReason(failure);
+            if (reason && failure !== void 0 && !emitted && !options.signal?.aborted && !((usage?.usage.totalTokens ?? 0) > 0) && attempt + 1 < refs.length) {
+              if (isGatewayKeyRejection(failure)) this.rememberRejectedKey(refs[attempt], gateway);
+              switchReason ??= reason;
+              failedRef ??= refs[attempt];
+              retry = true;
+              break;
+            }
+            if (chunk.reason.kind === "stop" || chunk.reason.kind === "tool-calls" || chunk.reason.kind === "max-tokens") announce();
+            if (usage) yield usage;
+            yield chunk;
+            return;
+          }
+          announce();
+          emitted = true;
+          yield chunk;
+        }
+        if (!retry) return;
+      } catch (error) {
+        const reason = error instanceof LlmError6 ? accountFailureReason(error) : void 0;
+        if (!reason || emitted || options.signal?.aborted || attempt + 1 >= refs.length) throw error;
+        if (error instanceof LlmError6 && isGatewayKeyRejection(error)) this.rememberRejectedKey(refs[attempt], gateway);
+        switchReason ??= reason;
+        failedRef ??= refs[attempt];
+      }
+    }
+  }
+  rememberRejectedKey(ref, gateway) {
+    const rejected = this.rejectedKeys.get(ref) ?? /* @__PURE__ */ new Map();
+    rejected.set(gateway, Date.now() + REJECTED_KEY_TTL_MS);
+    this.rejectedKeys.set(ref, rejected);
+  }
+  /** A stored change to a reference outranks the gateway's last rejection of it. */
+  forgetRejectedKey(ref) {
+    this.rejectedKeys.delete(ref);
+  }
+  /** One account, one SDK attempt; host recovery still owns failures after output. */
+  async *streamAttempt(options, snapshot) {
     var _stack = [];
     try {
       if (options.stop !== void 0) {
@@ -1691,6 +1903,7 @@ var OpencodeGoAdapter = class extends LlmAdapter {
         const context = imageRequest === void 0 ? toPiContext(options, void 0, this.options.onReplayDegrade) : await toPiContext({ ...options, signal: watchdog.signal }, imageRequest, this.options.onReplayDegrade);
         const events = catalog.provider.streamSimple(withRequestReasoning(model, reasoning), normalizeContext(context), {
           apiKey,
+          fetch: this.transport.forProxy(config.proxyURL),
           ...reasoning === void 0 || reasoning === "off" ? {} : { reasoning },
           ...options.temperature === void 0 ? {} : { temperature: options.temperature },
           ...maxTokens === void 0 ? {} : { maxTokens },
@@ -1753,6 +1966,11 @@ import { RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protoc
 import { attributionHeaders as attributionHeaders3 } from "@deepseek-ai/dsh-llm";
 
 // src/usage-contract.ts
+function parseAccountSwitch(value) {
+  const notice = value;
+  if (!notice || typeof notice.fromRef !== "string" || typeof notice.toRef !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(notice.fromRef) || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(notice.toRef) || notice.reason !== "quota" && notice.reason !== "credential" || typeof notice.at !== "number" || !Number.isSafeInteger(notice.at) || notice.at < 0 || notice.at > 864e13) throw new Error("Invalid account switch notice");
+  return { fromRef: notice.fromRef, toRef: notice.toRef, reason: notice.reason, at: notice.at };
+}
 function parseGoUsage(value) {
   if (!value || typeof value !== "object") throw new Error("Invalid OpenCode Go usage response");
   const source = value;
@@ -1763,6 +1981,9 @@ function parseGoUsage(value) {
     }
     result.source = source.source;
   }
+  if (source.lastSwitch !== void 0) {
+    result.lastSwitch = parseAccountSwitch(source.lastSwitch);
+  }
   for (const key of ["rolling", "weekly", "monthly"]) {
     const row = source[key];
     if (!row || row.status !== "ok" && row.status !== "rate-limited" || typeof row.percent !== "number" || !Number.isFinite(row.percent) || row.percent < 0 || typeof row.resetsAt !== "string" || !Number.isFinite(Date.parse(row.resetsAt))) {
@@ -1778,6 +1999,16 @@ var usageCodec = {
   schema: { parse: parseGoUsage },
   create: () => ({ parse: parseGoUsage })
 };
+var parseRef = (value) => {
+  if (typeof value !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) throw new Error("Invalid account reference");
+  return value;
+};
+var refCodec = {
+  mode: "strict",
+  typeSymbol: "dsh-opencode-go#AccountRef",
+  schema: { parse: parseRef },
+  create: () => ({ parse: parseRef })
+};
 var usageRemote = {
   package: "dsh-opencode-go",
   descriptors: [{
@@ -1788,6 +2019,14 @@ var usageRemote = {
     invocation: { kind: "direct" },
     parameters: [],
     result: usageCodec
+  }, {
+    id: "dsh-opencode-go#opencodeGoUsage/readAccount",
+    service: "opencodeGoUsage",
+    namespace: "opencodeGoUsage",
+    method: "readAccount",
+    invocation: { kind: "direct" },
+    parameters: [{ name: "ref", wire: "ref", source: "json", codec: refCodec }],
+    result: usageCodec
   }]
 };
 
@@ -1797,15 +2036,48 @@ var GoUsageService = class extends TypertRemoteService {
   constructor(ctx, options) {
     super(ctx, "opencodeGoUsage");
     this.options = options;
+    this.transport = options.transport ?? new ProxyTransport();
+    if (!options.transport) ctx.effect(() => () => this.transport.dispose());
   }
-  identity;
+  identities = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  transport;
   async read() {
+    try {
+      const usage = await this.readRef(this.options.activeRef?.());
+      const lastSwitch = this.options.lastSwitch?.();
+      return lastSwitch ? { ...usage, lastSwitch } : usage;
+    } catch (error) {
+      const lastSwitch = this.options.lastSwitch?.();
+      if (lastSwitch && error instanceof RemoteError && error.code === "opencode-go/usage-unavailable") {
+        throw new RemoteError(
+          "opencode-go/usage-unavailable",
+          error.message,
+          { ...error.details, lastSwitch },
+          { cause: error }
+        );
+      }
+      throw error;
+    }
+  }
+  async readAccount(ref) {
+    if (!this.options.accountRefs?.().includes(ref)) {
+      throw new RemoteError("gateway/bad-request", "Unknown OpenCode Go account", {});
+    }
+    return this.readRef(ref);
+  }
+  async readRef(ref) {
+    const identityKey = ref ?? "";
+    if (this.options.accountRefs) for (const saved of this.identities.keys()) {
+      if (saved && !this.options.accountRefs().includes(saved)) this.identities.delete(saved);
+    }
     const baseURL = assertBaseURL(this.options.baseURL()).replace(/\/$/, "");
+    const proxyURL = assertProxyURL(this.options.proxyURL?.());
     let key;
     try {
-      key = await this.options.resolveApiKey();
+      key = await this.options.resolveApiKey(ref);
     } catch (error) {
-      this.identity = void 0;
+      this.identities.delete(identityKey);
       const missing = error instanceof Error && "code" in error && error.code === "MISSING_CREDENTIAL";
       throw new RemoteError("opencode-go/usage-unavailable", missing ? "OpenCode Go API key is not configured" : "Could not resolve the OpenCode Go API key", {
         retryable: !missing,
@@ -1813,16 +2085,29 @@ var GoUsageService = class extends TypertRemoteService {
       }, { cause: error });
     }
     if (!key) {
-      this.identity = void 0;
+      this.identities.delete(identityKey);
       throw new RemoteError("opencode-go/usage-unavailable", "OpenCode Go API key is not configured", {
         retryable: false,
         retainPrevious: false
       });
     }
-    if (this.identity?.baseURL !== baseURL || this.identity.key !== key) {
-      this.identity = { baseURL, key, source: randomUUID3() };
+    let identity = this.identities.get(identityKey);
+    if (identity?.baseURL !== baseURL || identity.proxyURL !== proxyURL || identity.key !== key) {
+      identity = { baseURL, proxyURL, key, source: randomUUID3() };
+      this.identities.set(identityKey, identity);
+    }
+    const { source } = identity;
+    const shared = this.pending.get(source);
+    if (shared) return shared;
+    const pending = this.fetchUsage(baseURL, key, source, this.transport.forProxy(proxyURL));
+    this.pending.set(source, pending);
+    try {
+      return await pending;
+    } finally {
+      this.pending.delete(source);
     }
-    const { source } = this.identity;
+  }
+  async fetchUsage(baseURL, key, source, fetcher) {
     const endpoint = diagnosticURL(`${baseURL}/usage`);
     let result;
     try {
@@ -1830,7 +2115,7 @@ var GoUsageService = class extends TypertRemoteService {
         headers: { ...attributionHeaders3(), Authorization: `Bearer ${key}`, Accept: "application/json" },
         signal: AbortSignal.timeout(1e4),
         redirect: "error"
-      }, USAGE_MAX_BYTES);
+      }, USAGE_MAX_BYTES, "identity", fetcher);
     } catch (error) {
       const invalid = error instanceof SyntaxError || error instanceof RangeError;
       const detail = error instanceof SyntaxError ? "invalid JSON response" : error instanceof RangeError ? `response exceeds the ${USAGE_MAX_BYTES} byte limit` : transportFailure(error);
@@ -1905,9 +2190,14 @@ function apply(ctx, raw) {
   const config = raw && typeof raw.enabled === "object" ? raw : Config(raw);
   const entry = readConfig(config);
   assertBaseURL(entry.baseURL);
+  assertProxyURL(entry.proxyURL);
+  assertAccounts(entry.accounts, entry.apiKeyEnv);
   let current = () => readConfig(config);
   const resolveApiKey = async (config2 = current()) => {
     const ref = config2.apiKeyEnv;
+    if (!accountsOf(config2).some((account) => account.apiKeyEnv === ref)) {
+      throw new LlmError7("OpenCode Go has no selected account", "MISSING_CREDENTIAL");
+    }
     const credentials = ctx.get("credentials");
     const hit = credentials !== void 0 ? (await credentials.resolve(credentialRef(ref)))?.value : launchEnvironmentOf(ctx).get(ref)?.value;
     if (hit !== void 0 && hit.length > 0) return assertUsableApiKey(hit, name, ref);
@@ -1917,7 +2207,18 @@ function apply(ctx, raw) {
     );
   };
   registerGoRemotes(ctx);
-  ctx.plugin(GoUsageService, { baseURL: () => current().baseURL, resolveApiKey });
+  let lastSwitch;
+  const transport = new ProxyTransport();
+  ctx.effect(() => () => transport.dispose());
+  ctx.plugin(GoUsageService, {
+    baseURL: () => current().baseURL,
+    proxyURL: () => current().proxyURL,
+    transport,
+    resolveApiKey: (ref) => resolveApiKey({ ...current(), apiKeyEnv: ref ?? current().apiKeyEnv }),
+    activeRef: () => accountRefOf(current()),
+    accountRefs: () => accountsOf(current()).map((account) => account.apiKeyEnv),
+    lastSwitch: () => lastSwitch
+  });
   const logger = {
     fallback: ({ url, error }) => {
       ctx.logger.warn(`llm-opencode-go: could not refresh ${url}; using last-known model data (${String(error)})`);
@@ -1928,8 +2229,13 @@ function apply(ctx, raw) {
   };
   let registration;
   const adapter = new OpencodeGoAdapter({
+    transport,
     config: () => current(),
     resolveApiKey,
+    onAccountSwitch: (notice, captured) => {
+      const config2 = current();
+      if (config2.baseURL === captured.baseURL && config2.proxyURL === captured.proxyURL && config2.apiKeyEnv === captured.apiKeyEnv && JSON.stringify(config2.accounts) === JSON.stringify(captured.accounts)) lastSwitch = notice;
+    },
     imageAccess: {
       resolveAttachments: () => ctx.get("attachments"),
       resolveImageAccess: (attachments, ref) => resolveImageAttachmentAccess(
@@ -1971,19 +2277,29 @@ function apply(ctx, raw) {
       }
     }
   };
+  let routeCheck = 0;
+  let accountIdentity = "";
   const syncRoute = () => {
+    const check = ++routeCheck;
+    const config2 = current();
+    const identity = JSON.stringify([config2.apiKeyEnv, config2.accounts, config2.baseURL, config2.proxyURL, config2.autoSwitch]);
+    if (identity !== accountIdentity) {
+      accountIdentity = identity;
+      lastSwitch = void 0;
+    }
     const visibility = pickerVisibilityOf();
     if (pickerVisibility !== visibility) {
       pickerVisibility = visibility;
       registration?.replace([PROVIDER_ID]);
     }
     const credentials = ctx.get("credentials");
+    const refs = accountsOf(config2).filter((account) => config2.autoSwitch || account.apiKeyEnv === config2.apiKeyEnv).map((account) => account.apiKeyEnv);
     if (credentials === void 0) {
-      applyRoute(launchEnvironmentOf(ctx).get(current().apiKeyEnv)?.value !== void 0);
+      applyRoute(refs.some((ref) => Boolean(launchEnvironmentOf(ctx).get(ref)?.value)));
       return;
     }
-    void credentials.describe(credentialRef(current().apiKeyEnv)).then((info) => {
-      applyRoute(info.configured);
+    void Promise.all(refs.map((ref) => credentials.describe(credentialRef(ref)))).then((infos) => {
+      if (check === routeCheck) applyRoute(infos.some((info) => info.configured));
     }).catch((error) => {
       ctx.logger.error(`llm-opencode-go: credential describe failed; keeping the previous route state (${String(error)})`);
     });
@@ -2012,6 +2328,8 @@ function apply(ctx, raw) {
     settingsCtx.settings.installSection(ctx, NS, PlainConfig, entry, {
       validate: (value) => {
         assertBaseURL(value.baseURL);
+        assertProxyURL(value.proxyURL);
+        assertAccounts(value.accounts, value.apiKeyEnv);
       },
       setSource: (source) => {
         current = source;
@@ -2023,13 +2341,22 @@ function apply(ctx, raw) {
   });
   ctx.on("internal/config", function(_raw, next) {
     const value = next();
-    if (this === ctx.fiber) assertBaseURL(PlainConfig(value).baseURL);
+    if (this === ctx.fiber) {
+      const config2 = PlainConfig(value);
+      assertBaseURL(config2.baseURL);
+      assertProxyURL(config2.proxyURL);
+      assertAccounts(config2.accounts, config2.apiKeyEnv);
+    }
     return value;
   });
   ctx.on("loader/volatile-update", syncRoute);
   ctx.inject(["credentials"], (credentialsCtx) => {
     credentialsCtx.on("credentials/reference-updated", (ref) => {
-      if (ref === current().apiKeyEnv) syncRoute();
+      adapter.forgetRejectedKey(ref);
+      if (accountsOf(current()).some((account) => account.apiKeyEnv === ref)) {
+        lastSwitch = void 0;
+        syncRoute();
+      }
     });
     syncRoute();
   });
@@ -2045,6 +2372,7 @@ export {
   PlainConfig,
   apply,
   assertBaseURL,
+  assertProxyURL,
   discoverCatalogModels,
   inject,
   name,

package/lib/types/accounts.d.ts

@@ -0,0 +1,26 @@
+/** Client-safe account metadata. Secrets stay in the host credential service. */
+export type GoAccount = {
+    id: string;
+    name: string;
+    apiKeyEnv: string;
+};
+export declare const MAX_ACCOUNTS = 20;
+export declare const ACCOUNT_REF_PREFIX = "DSH_OPENCODE_GO_ACCOUNT_";
+export declare const DEFAULT_ACCOUNT_REF = "OPENCODE_API_KEY";
+export interface AccountSettings {
+    apiKeyEnv?: string;
+    /** Omission/null preserves legacy credentials; an explicit empty list removes all accounts. */
+    accounts?: readonly GoAccount[] | null;
+    autoSwitch?: boolean;
+}
+export declare function accountRefOf(settings: AccountSettings): string;
+/** Include an externally selected reference without rewriting existing configuration. */
+export declare function accountsOf(settings: AccountSettings): readonly GoAccount[];
+export declare function assertAccounts(accounts: readonly GoAccount[] | null | undefined, selectedRef?: string): void;
+/** Safe UI notice for a successful request using a fallback account. */
+export interface GoAccountSwitch {
+    fromRef: string;
+    toRef: string;
+    reason: 'quota' | 'credential';
+    at: number;
+}