@desplega.ai/agent-swarm 1.173.0 → 2.0.0

package/src/providers/opencode-adapter.ts

@@ -9,13 +9,28 @@
 
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import {
+  baseUrlOverride,
+  ignoredBaseUrlVar,
+  type OpenAICompatibleProvider,
+  openAICompatibleKeyVars,
+  openAICompatibleProvider,
+  openAICompatibleProviders,
+  providerBaseUrl,
+  providerForKeyVar,
+  providerKeyVars,
+} from "@desplega/model-catalog";
 import type { OpenCode, OpenCodeEvent } from "@opencode/sdk";
 import {
   CONTEXT_FORMULA,
   clampContextPercent,
   getContextWindowSize,
 } from "../utils/context-window";
-import { validateOpencodeCredentials } from "../utils/credentials";
+import {
+  openAICompatibleKeyLabels,
+  splitCredentialPool,
+  validateOpencodeCredentials,
+} from "../utils/credentials";
 import { isEnvFlagEnabled } from "../utils/env-flag";
 import { fetchInstalledMcpServers } from "../utils/mcp-server-fetcher";
 import { swarmRuntimeInstanceId } from "../utils/multi-runtime";
@@ -24,7 +39,7 @@ import {
   getOpenRouterAttributionHeaders,
   getOpenRouterBaseUrl,
 } from "../utils/openrouter-base-url";
-import { scrubSecrets } from "../utils/secret-scrubber";
+import { registerVolatileSecret, scrubSecrets } from "../utils/secret-scrubber";
 import { resolveSlashSkillPrompt } from "./codex-skill-resolver";
 import { CTX_MODE_NUDGE_EVERY } from "./ctx-mode-env";
 import { OpenRouterBilling } from "./opencode-billing";
@@ -61,8 +76,12 @@ export type OpencodeConfig = {
   provider?: Record<
     string,
     {
+      /** Env var names OpenCode reads the key from; `[]` stops it reading `process.env`. */
+      env?: string[];
+      npm?: string;
+      name?: string;
       options?: Record<string, unknown>;
-      models?: Record<string, { options?: Record<string, unknown> }>;
+      models?: Record<string, { options?: Record<string, unknown>; [key: string]: unknown }>;
     }
   >;
   [key: string]: unknown;
@@ -80,18 +99,41 @@ function opencodeModelToCredKey(modelStr: string | undefined): string | null {
     if (provider === "anthropic") return "ANTHROPIC_API_KEY";
     if (provider === "openrouter") return "OPENROUTER_API_KEY";
     if (provider === "openai") return "OPENAI_API_KEY";
+    // OpenAI-compatible registry providers (`nan`, `helmcode`).
+    const direct = openAICompatibleProvider(provider);
+    if (direct) return direct.envVar;
   }
   return null;
 }
 
+/**
+ * Env var names that satisfy `requiredKey`. The runner copies a registry
+ * key alias (`HELMCODE_API_NAN`) into its canonical var per task, but a
+ * check that reads `process.env` directly sees only the alias.
+ */
+function credKeyNames(requiredKey: string): readonly string[] {
+  const direct = providerForKeyVar(requiredKey);
+  return direct ? providerKeyVars(direct) : [requiredKey];
+}
+
+/** Keys that satisfy opencode when no model pins a provider. */
+const OPENCODE_ANY_KEY_VARS = [
+  "OPENROUTER_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  ...openAICompatibleKeyVars(),
+];
+
 /**
  * Opencode is satisfied by ANY of:
  *   1. `~/.local/share/opencode/auth.json` exists (the file `opencode auth login`
  *      writes; OpenCode 2 imports it into its credential store on start).
  *   2. `MODEL_OVERRIDE` resolves to a provider-prefixed model — only that
- *      provider's key is required.
+ *      provider's key is required (a registry provider also accepts its key
+ *      aliases: `nan/*` takes `HELMCODE_API_NAN`).
  *   3. Otherwise any one of OPENROUTER_API_KEY / ANTHROPIC_API_KEY /
- *      OPENAI_API_KEY suffices.
+ *      OPENAI_API_KEY / a registry provider key (canonical or alias)
+ *      suffices.
  */
 export function checkOpencodeCredentials(
   env: Record<string, string | undefined>,
@@ -106,7 +148,7 @@ export function checkOpencodeCredentials(
 
   const requiredKey = opencodeModelToCredKey(env.MODEL_OVERRIDE);
   if (requiredKey) {
-    if (env[requiredKey]) {
+    if (credKeyNames(requiredKey).some((name) => env[name])) {
       return { ready: true, missing: [], satisfiedBy: "env" };
     }
     return {
@@ -116,13 +158,26 @@ export function checkOpencodeCredentials(
     };
   }
 
-  if (env.OPENROUTER_API_KEY || env.ANTHROPIC_API_KEY || env.OPENAI_API_KEY) {
+  if (OPENCODE_ANY_KEY_VARS.some((name) => env[name])) {
     return { ready: true, missing: [], satisfiedBy: "env" };
   }
   return {
     ready: false,
-    missing: ["OPENROUTER_API_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY", authFile],
-    hint: "Set one of OPENROUTER_API_KEY / ANTHROPIC_API_KEY / OPENAI_API_KEY (any one suffices), or run `opencode auth login` to create ~/.local/share/opencode/auth.json.",
+    missing: [
+      "OPENROUTER_API_KEY",
+      "ANTHROPIC_API_KEY",
+      "OPENAI_API_KEY",
+      ...openAICompatibleProviders().map((p) => p.envVar),
+      authFile,
+    ],
+    hint: `Set one of ${[
+      "OPENROUTER_API_KEY",
+      "ANTHROPIC_API_KEY",
+      "OPENAI_API_KEY",
+      ...openAICompatibleKeyLabels(),
+    ].join(
+      " / ",
+    )} (any one suffices), or run \`opencode auth login\` to create ~/.local/share/opencode/auth.json.`,
   };
 }
 
@@ -217,6 +272,150 @@ export function applyOpenRouterBaseUrlOverride(
   };
 }
 
+/**
+ * OpenCode provider block for an OpenAI-compatible registry provider that
+ * OpenCode does not ship (`catalog: "registry"`, e.g. `helmcode`). `apiKey` is
+ * a literal key (embedded host) or an `{env:NAME}` reference (ACP
+ * subprocess). `baseUrl` is the `<ID>_BASE_URL` override or the registry
+ * default. `env: []` keeps OpenCode from reading a key out of `process.env`.
+ * A `modelId` missing from the registry (accepted through `allowCustomModel`)
+ * gets a bare entry so OpenCode still resolves it instead of falling back to
+ * its default model.
+ */
+export function buildOpenAICompatibleProviderBlock(
+  provider: OpenAICompatibleProvider,
+  apiKey: string,
+  modelId?: string,
+  baseUrl: string = provider.baseUrl,
+): NonNullable<OpencodeConfig["provider"]>[string] {
+  const models: Record<string, Record<string, unknown>> = {};
+  for (const m of provider.models) {
+    models[m.id] = {
+      name: m.name,
+      tool_call: true,
+      reasoning: m.reasoning,
+      limit: { context: m.contextWindow, output: m.maxOutputTokens },
+    };
+  }
+  if (modelId && !models[modelId]) models[modelId] = { name: modelId, tool_call: true };
+  return {
+    npm: provider.npm,
+    name: provider.displayName,
+    env: [],
+    options: { baseURL: baseUrl, apiKey },
+    models,
+  };
+}
+
+/**
+ * Built-in OpenCode providers whose key OpenCode reads from `process.env`:
+ * `openrouter` plus every registry provider models.dev lists
+ * (`catalog: "models.dev"`, e.g. `nan`), which OpenCode ships built in.
+ */
+function envBoundKeyVars(providerId: string): readonly string[] | undefined {
+  if (providerId === "openrouter") return ["OPENROUTER_API_KEY"];
+  const direct = openAICompatibleProvider(providerId);
+  return direct?.catalog === "models.dev" ? providerKeyVars(direct) : undefined;
+}
+
+/** Registry providers OpenCode does not ship (`catalog: "registry"`); they get a full custom block. */
+function customBlockProvider(providerId: string): OpenAICompatibleProvider | undefined {
+  const direct = openAICompatibleProvider(providerId);
+  return direct?.catalog === "registry" ? direct : undefined;
+}
+
+/**
+ * One key from the first non-empty var in `names`. The runner's per-task env
+ * already holds one picked pool member; a value that still carries a comma
+ * pool (no runner, or `process.env`) yields its first member.
+ */
+function pickProviderKey(
+  env: Record<string, string | undefined>,
+  names: readonly string[],
+): { key: string; name: string } | undefined {
+  for (const name of names) {
+    const value = env[name]?.trim();
+    if (!value) continue;
+    const key = splitCredentialPool(value)[0];
+    if (key) return { key, name };
+  }
+  return undefined;
+}
+
+/**
+ * Hand the embedded host exactly one key for the active model's provider.
+ *
+ * Embedded OpenCode reads a built-in provider's key from the shared
+ * `process.env`, and that value beats `options.apiKey`. The entrypoint exports
+ * a credential pool there as a raw comma list, and a key saved from the
+ * dashboard after boot never reaches `process.env` at all, so both 401 without
+ * this splice. For `openrouter` and the built-in registry providers (`nan`,
+ * `vercel`) it sets `env: []` plus `options.apiKey` (and `options.baseURL`
+ * when `<ID>_BASE_URL` is set; a `baseUrlLocked` provider gets none); for registry providers OpenCode does not ship
+ * (`helmcode`) it writes the full custom provider block at
+ * `<ID>_BASE_URL` or the registry default. No splice when the key is absent
+ * (credStatus reports that).
+ *
+ * The key lives only in the in-memory config string handed to the SDK.
+ * Mutates `opencodeConfig` in place and returns the env var the key came from,
+ * or `undefined` when nothing was spliced.
+ */
+export function applyProviderKeySplice(
+  opencodeConfig: OpencodeConfig,
+  model: string | undefined,
+  env: Record<string, string | undefined>,
+): { key: string; name: string } | undefined {
+  const slash = model?.indexOf("/") ?? -1;
+  if (!model || slash <= 0) return undefined;
+  const providerId = model.slice(0, slash);
+  const existing = opencodeConfig.provider?.[providerId];
+
+  const custom = customBlockProvider(providerId);
+  if (custom) {
+    const picked = pickProviderKey(env, providerKeyVars(custom));
+    if (!picked) return undefined;
+    const block = buildOpenAICompatibleProviderBlock(
+      custom,
+      picked.key,
+      model.slice(slash + 1),
+      providerBaseUrl(custom, env),
+    );
+    opencodeConfig.provider = {
+      ...opencodeConfig.provider,
+      [providerId]: {
+        ...existing,
+        ...block,
+        options: { ...existing?.options, ...block.options },
+        models: { ...existing?.models, ...block.models },
+      },
+    };
+    return picked;
+  }
+
+  const names = envBoundKeyVars(providerId);
+  if (!names) return undefined;
+  const picked = pickProviderKey(env, names);
+  if (!picked) return undefined;
+  const direct = openAICompatibleProvider(providerId);
+  const baseURL = direct ? baseUrlOverride(direct, env) : undefined;
+  const options = { ...existing?.options, ...(baseURL ? { baseURL } : {}), apiKey: picked.key };
+  if (direct?.baseUrlLocked) {
+    // OpenCode's built-in SDK (AI Gateway) knows its endpoint; any URL here is wrong.
+    const ignored = ignoredBaseUrlVar(direct, env);
+    if (ignored || options.baseURL !== undefined) {
+      console.warn(
+        `[opencode] ${ignored ?? `provider.${providerId}.options.baseURL`} is ignored: ${direct.displayName} uses its built-in endpoint`,
+      );
+    }
+    delete options.baseURL;
+  }
+  opencodeConfig.provider = {
+    ...opencodeConfig.provider,
+    [providerId]: { ...existing, env: [], options },
+  };
+  return picked;
+}
+
 const SWARM_AGENT_NAME = "swarm";
 const TRANSCRIPT_TAIL_CHARS = 20_000;
 const TOOL_RESULT_PREVIEW_CHARS = 500;
@@ -547,8 +746,11 @@ export class OpencodeSession implements ProviderSession {
   }
 
   /** Settle the session as failed; also used when the event stream dies. */
-  fail(message: string): void {
+  fail(rawMessage: string): void {
     if (this.aborted || this.completed) return;
+    // SDK and provider errors can echo request details; the message reaches
+    // the runner's logs and the task's failure reason.
+    const message = scrubSecrets(rawMessage);
     this.emit({ type: "error", message });
     void this.finish(async () => ({
       exitCode: 1,
@@ -733,6 +935,12 @@ export class OpencodeAdapter implements ProviderAdapter {
       },
     };
 
+    // One picked key for the model's provider (D3). It stays in this
+    // in-memory config; registering it lets every scrubbed egress redact it
+    // even when it never reached `process.env` (a key saved after boot).
+    const splicedKey = applyProviderKeySplice(opencodeConfig, config.model, env);
+    if (splicedKey) registerVolatileSecret(splicedKey.key, splicedKey.name);
+
     // Splice the provider-keyed reasoning options into
     // `provider[providerId].models[modelId].options`. `off` (and any
     // capability-rejected level) resolves to `noop`.
@@ -774,21 +982,30 @@ export class OpencodeAdapter implements ProviderAdapter {
     const { sdk, version: opencodeVersion } = await loadOpencodeSdkImpl();
     let listTools: OpencodeToolLister | undefined;
     const billing = config.model.startsWith("openrouter/") ? new OpenRouterBilling() : undefined;
-    const host = await sdk.OpenCode.create({
-      config: { content: JSON.stringify(opencodeConfig) },
-      plugins: [
-        createOpencodeSwarmPlugin(swarm, {
-          onToolRegistry: (lister) => {
-            listTools = lister;
-          },
-          ...(billing ? { onOpenRouterResponse: (response) => billing.observe(response) } : {}),
-        }),
-      ],
-      log: {
-        level: "warn",
-        emit: (entry) => console.warn(scrubSecrets(`[opencode] ${entry.message}`)),
-      },
-    });
+    // The config string carries the spliced provider key and the swarm MCP
+    // bearer. It goes to the SDK only; nothing logs, writes, or uploads it,
+    // and errors raised while the SDK parses it are scrubbed before they
+    // propagate to the runner.
+    let host: OpenCode.Interface;
+    try {
+      host = await sdk.OpenCode.create({
+        config: { content: JSON.stringify(opencodeConfig) },
+        plugins: [
+          createOpencodeSwarmPlugin(swarm, {
+            onToolRegistry: (lister) => {
+              listTools = lister;
+            },
+            ...(billing ? { onOpenRouterResponse: (response) => billing.observe(response) } : {}),
+          }),
+        ],
+        log: {
+          level: "warn",
+          emit: (entry) => console.warn(scrubSecrets(`[opencode] ${entry.message}`)),
+        },
+      });
+    } catch (err) {
+      throw new Error(scrubSecrets(`opencode host failed to start: ${errorMessage(err, "")}`));
+    }
 
     let sessionId: string;
     try {
@@ -799,7 +1016,7 @@ export class OpencodeAdapter implements ProviderAdapter {
       sessionId = created.id;
     } catch (err) {
       await host.close().catch(() => {});
-      throw err;
+      throw new Error(scrubSecrets(`opencode session create failed: ${errorMessage(err, "")}`));
     }
 
     const session = new OpencodeSession(

package/src/providers/opencode-swarm-plugin.ts

@@ -32,6 +32,27 @@ export interface OpencodeSwarmPluginOptions {
   onOpenRouterResponse?: (response: Response) => void;
 }
 
+/** Keys OpenCode sets on each shell call, on top of its base env. */
+const OPENCODE_SHELL_ENV_KEYS = ["TERM", "OPENCODE_TERMINAL"] as const;
+
+/**
+ * Rewrites one OpenCode shell call's env, in place, to the session's own env
+ * plus the keys OpenCode set for the call. Nothing else from the process env
+ * gets through.
+ */
+function applyOpencodeShellEnv(
+  callEnv: Record<string, string | undefined>,
+  sessionEnv: Record<string, string | undefined>,
+): void {
+  const keep = new Set<string>(OPENCODE_SHELL_ENV_KEYS);
+  for (const key of Object.keys(callEnv)) {
+    if (!keep.has(key)) delete callEnv[key];
+  }
+  for (const [key, value] of Object.entries(sessionEnv)) {
+    if (value !== undefined && !keep.has(key)) callEnv[key] = value;
+  }
+}
+
 export function createOpencodeSwarmPlugin(
   config: SwarmHooksConfig,
   options: OpencodeSwarmPluginOptions = {},
@@ -41,6 +62,16 @@ export function createOpencodeSwarmPlugin(
     async setup(ctx) {
       options.onToolRegistry?.(() => ctx.tool.list());
 
+      // OpenCode runs in-process, so its shell tool spawns with process.env,
+      // which every concurrent session shares and which never sees this
+      // task's env (rows admitted or withheld by fetchResolvedEnv after boot).
+      const sessionEnv = config.env;
+      if (sessionEnv) {
+        await ctx.shell.hook("create.before", (event) => {
+          applyOpencodeShellEnv(event.env, sessionEnv);
+        });
+      }
+
       // A throw blocks the tool; OpenCode hands the message back to the model.
       await ctx.tool.hook("execute.before", async (event) => {
         if (!config.isLead && config.taskId) {