@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/dist/{cli-j1pmc07z.js → cli-vatyhshy.js}

@@ -9,7 +9,7 @@ import {
   renderGoalReminder,
   summarizeTranscript,
   syncIdentityFilesToServer
-} from "./cli-bf7485pm.js";
+} from "./cli-apx87jne.js";
 import {
   fetchInstalledMcpServers
 } from "./cli-tng3131n.js";
@@ -23,17 +23,19 @@ import {
   CONTEXT_FORMULA,
   clampContextPercent,
   getContextWindowSize
-} from "./cli-7avy4v8w.js";
+} from "./cli-w1q7h2r2.js";
 import {
   applyReasoningEffort
-} from "./cli-tmhsxhb8.js";
+} from "./cli-n5vwg842.js";
 import {
   swarmRuntimeInstanceId
 } from "./cli-re8z5p8p.js";
 import {
   init_credentials,
+  openAICompatibleKeyLabels,
+  splitCredentialPool,
   validateOpencodeCredentials
-} from "./cli-tadfgd0t.js";
+} from "./cli-5hkm7whv.js";
 import {
   DEFAULT_OPENROUTER_BASE_URL,
   getOpenRouterAttributionHeaders,
@@ -46,10 +48,23 @@ import {
 } from "./cli-ej6gbxfb.js";
 import {
   init_secret_scrubber,
+  registerVolatileSecret,
   scrubSecrets
-} from "./cli-d161g69q.js";
+} from "./cli-p1x85d2t.js";
+import {
+  baseUrlOverride,
+  ignoredBaseUrlVar,
+  init_src,
+  openAICompatibleKeyVars,
+  openAICompatibleProvider,
+  openAICompatibleProviders,
+  providerBaseUrl,
+  providerForKeyVar,
+  providerKeyVars
+} from "./cli-e3g5mbkz.js";
 
 // src/providers/opencode-adapter.ts
+init_src();
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 init_credentials();
@@ -57,12 +72,89 @@ init_env_flag();
 init_openrouter_base_url();
 init_secret_scrubber();
 
+// src/providers/opencode-billing.ts
+function parseOpenRouterBilledCost(body) {
+  const payloads = body.trimStart().startsWith("{") ? [body] : body.split(`
+`).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
+  let cost = null;
+  for (const payload of payloads) {
+    if (!payload.includes('"cost"'))
+      continue;
+    let usage;
+    try {
+      usage = JSON.parse(payload).usage;
+    } catch {
+      continue;
+    }
+    if (usage?.is_byok === true)
+      return null;
+    if (typeof usage?.cost === "number" && Number.isFinite(usage.cost))
+      cost = usage.cost;
+  }
+  return cost;
+}
+
+class OpenRouterBilling {
+  requests = 0;
+  billed = 0;
+  costUsd = 0;
+  pending = new Set;
+  observe(response) {
+    this.requests++;
+    if (!response.ok) {
+      this.billed++;
+      return;
+    }
+    const read = response.clone().text().then((body) => {
+      const cost = parseOpenRouterBilledCost(body);
+      if (cost === null)
+        return;
+      this.billed++;
+      this.costUsd += cost;
+    }).catch(() => {}).finally(() => this.pending.delete(read));
+    this.pending.add(read);
+  }
+  async settle(timeoutMs) {
+    if (this.pending.size > 0) {
+      let timer;
+      await Promise.race([
+        Promise.all(this.pending),
+        new Promise((resolve) => {
+          timer = setTimeout(resolve, timeoutMs);
+        })
+      ]);
+      clearTimeout(timer);
+    }
+    if (this.requests === 0)
+      return null;
+    return { costUsd: this.costUsd, complete: this.billed === this.requests };
+  }
+}
+
 // src/providers/opencode-swarm-plugin.ts
+var OPENCODE_SHELL_ENV_KEYS = ["TERM", "OPENCODE_TERMINAL"];
+function applyOpencodeShellEnv(callEnv, sessionEnv) {
+  const keep = new Set(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;
+  }
+}
 function createOpencodeSwarmPlugin(config, options = {}) {
   return {
     id: "agent-swarm",
     async setup(ctx) {
       options.onToolRegistry?.(() => ctx.tool.list());
+      const sessionEnv = config.env;
+      if (sessionEnv) {
+        await ctx.shell.hook("create.before", (event) => {
+          applyOpencodeShellEnv(event.env, sessionEnv);
+        });
+      }
       await ctx.tool.hook("execute.before", async (event) => {
         if (!config.isLead && config.taskId) {
           const { cancelled, reason } = await isTaskCancelled(config);
@@ -90,6 +182,15 @@ function createOpencodeSwarmPlugin(config, options = {}) {
         if (concurrent)
           event.system.push({ type: "text", text: concurrent });
       });
+      await ctx.session.hook("title", (event) => {
+        event.result = config.taskId ? `swarm task ${config.taskId}` : "swarm session";
+      });
+      const onOpenRouterResponse = options.onOpenRouterResponse;
+      if (onOpenRouterResponse) {
+        await ctx.session.hook("http.response", (event) => {
+          onOpenRouterResponse(event.response);
+        }, { providerID: "openrouter" });
+      }
       await ctx.session.hook("compaction", async (event) => {
         if (!config.taskId)
           return;
@@ -116,9 +217,22 @@ function opencodeModelToCredKey(modelStr) {
       return "OPENROUTER_API_KEY";
     if (provider === "openai")
       return "OPENAI_API_KEY";
+    const direct = openAICompatibleProvider(provider);
+    if (direct)
+      return direct.envVar;
   }
   return null;
 }
+function credKeyNames(requiredKey) {
+  const direct = providerForKeyVar(requiredKey);
+  return direct ? providerKeyVars(direct) : [requiredKey];
+}
+var OPENCODE_ANY_KEY_VARS = [
+  "OPENROUTER_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  ...openAICompatibleKeyVars()
+];
 function checkOpencodeCredentials(env, opts = {}) {
   const homeDir = opts.homeDir ?? env.HOME ?? "/root";
   const probe = opts.fs?.existsSync ?? existsSync;
@@ -128,7 +242,7 @@ function checkOpencodeCredentials(env, opts = {}) {
   }
   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 {
@@ -137,13 +251,24 @@ function checkOpencodeCredentials(env, opts = {}) {
       hint: `MODEL_OVERRIDE=${env.MODEL_OVERRIDE} requires ${requiredKey}; or run \`opencode auth login\` to create ${authFile}.`
     };
   }
-  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.`
   };
 }
 function defaultOpencodeSkillsDir() {
@@ -207,9 +332,96 @@ function applyOpenRouterBaseUrlOverride(opencodeConfig, env = process.env) {
     }
   };
 }
+function buildOpenAICompatibleProviderBlock(provider, apiKey, modelId, baseUrl = provider.baseUrl) {
+  const models = {};
+  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
+  };
+}
+function envBoundKeyVars(providerId) {
+  if (providerId === "openrouter")
+    return ["OPENROUTER_API_KEY"];
+  const direct = openAICompatibleProvider(providerId);
+  return direct?.catalog === "models.dev" ? providerKeyVars(direct) : undefined;
+}
+function customBlockProvider(providerId) {
+  const direct = openAICompatibleProvider(providerId);
+  return direct?.catalog === "registry" ? direct : undefined;
+}
+function pickProviderKey(env, names) {
+  for (const name of names) {
+    const value = env[name]?.trim();
+    if (!value)
+      continue;
+    const key = splitCredentialPool(value)[0];
+    if (key)
+      return { key, name };
+  }
+  return;
+}
+function applyProviderKeySplice(opencodeConfig, model, env) {
+  const slash = model?.indexOf("/") ?? -1;
+  if (!model || slash <= 0)
+    return;
+  const providerId = model.slice(0, slash);
+  const existing = opencodeConfig.provider?.[providerId];
+  const custom = customBlockProvider(providerId);
+  if (custom) {
+    const picked2 = pickProviderKey(env, providerKeyVars(custom));
+    if (!picked2)
+      return;
+    const block = buildOpenAICompatibleProviderBlock(custom, picked2.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 picked2;
+  }
+  const names = envBoundKeyVars(providerId);
+  if (!names)
+    return;
+  const picked = pickProviderKey(env, names);
+  if (!picked)
+    return;
+  const direct = openAICompatibleProvider(providerId);
+  const baseURL = direct ? baseUrlOverride(direct, env) : undefined;
+  const options = { ...existing?.options, ...baseURL ? { baseURL } : {}, apiKey: picked.key };
+  if (direct?.baseUrlLocked) {
+    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;
+}
 var SWARM_AGENT_NAME = "swarm";
 var TRANSCRIPT_TAIL_CHARS = 20000;
 var TOOL_RESULT_PREVIEW_CHARS = 500;
+var BILLING_SETTLE_MS = 2000;
 var SWARM_MCP_SERVER = "swarm";
 var REQUIRED_SWARM_TOOLS = ["store-progress"];
 var ADMISSION_POLL_MS = 250;
@@ -278,6 +490,7 @@ class OpencodeSession {
   swarm;
   cwd;
   appliedReasoningEffort;
+  billing;
   listeners = [];
   pendingEvents = [];
   completionResolve;
@@ -294,13 +507,14 @@ class OpencodeSession {
   toolNames = new Map;
   textByMessage = new Map;
   transcript = [];
-  constructor(host, _sessionId, model, swarm, cwd, appliedReasoningEffort = null) {
+  constructor(host, _sessionId, model, swarm, cwd, appliedReasoningEffort = null, billing) {
     this.host = host;
     this._sessionId = _sessionId;
     this.model = model;
     this.swarm = swarm;
     this.cwd = cwd;
     this.appliedReasoningEffort = appliedReasoningEffort;
+    this.billing = billing;
     this.completionPromise = new Promise((resolve) => {
       this.completionResolve = resolve;
     });
@@ -431,12 +645,13 @@ class OpencodeSession {
       case "session.usage.updated":
         this.usage = { cost: ev.data.cost, tokens: ev.data.tokens };
         break;
-      case "session.execution.succeeded": {
-        const cost = this.buildCostData(false);
-        this.emit({ type: "result", cost, isError: false });
-        this.finish({ exitCode: 0, sessionId: this._sessionId, cost, isError: false });
+      case "session.execution.succeeded":
+        this.finish(async () => {
+          const cost = await this.buildCostData(false);
+          this.emit({ type: "result", cost, isError: false });
+          return { exitCode: 0, sessionId: this._sessionId, cost, isError: false };
+        });
         break;
-      }
       case "session.execution.failed":
         this.fail(errorMessage(ev.data.error, "opencode session error"));
         break;
@@ -459,27 +674,29 @@ class OpencodeSession {
       autoIndexMemoryFile(this.swarm, path);
     }
   }
-  fail(message) {
+  fail(rawMessage) {
     if (this.aborted || this.completed)
       return;
+    const message = scrubSecrets(rawMessage);
     this.emit({ type: "error", message });
-    this.finish({
+    this.finish(async () => ({
       exitCode: 1,
       sessionId: this._sessionId,
-      cost: this.buildCostData(true),
+      cost: await this.buildCostData(true),
       isError: true,
       failureReason: message
-    });
+    }));
   }
-  buildCostData(isError) {
+  async buildCostData(isError) {
     const { cost, tokens } = this.usage;
+    const billed = await this.billing?.settle(BILLING_SETTLE_MS);
     return {
       sessionId: this._sessionId,
       taskId: this.swarm.taskId,
       agentId: this.swarm.agentId,
-      totalCostUsd: cost,
+      ...billed?.complete ? { totalCostUsd: billed.costUsd, harnessCostBilled: true } : { totalCostUsd: cost },
       inputTokens: tokens.input,
-      outputTokens: tokens.output,
+      outputTokens: tokens.output + tokens.reasoning,
       reasoningOutputTokens: tokens.reasoning,
       cacheReadTokens: tokens.cache.read,
       cacheWriteTokens: tokens.cache.write,
@@ -507,11 +724,12 @@ class OpencodeSession {
       headers: apiHeaders(this.swarm)
     });
   }
-  async finish(result) {
+  async finish(settle) {
     if (this.completed)
       return;
     this.completed = true;
     const { signal } = this.sessionEnd;
+    const result = typeof settle === "function" ? await settle() : settle;
     try {
       if (!this.aborted) {
         await settleWithin(this.runSessionEnd(signal), sessionHooks.budgetMs, signal);
@@ -607,6 +825,9 @@ class OpencodeAdapter {
         [SWARM_AGENT_NAME]: { mode: "primary", prompt: config.systemPrompt ?? "" }
       }
     };
+    const splicedKey = applyProviderKeySplice(opencodeConfig, config.model, env);
+    if (splicedKey)
+      registerVolatileSecret(splicedKey.key, splicedKey.name);
     const reasoningApplication = applyReasoningEffort("opencode", config.model, config.reasoningEffort);
     const appliedReasoningEffort = reasoningApplication.kind === "opencode-options" ? config.reasoningEffort ?? null : null;
     if (reasoningApplication.kind === "opencode-options") {
@@ -637,20 +858,27 @@ class OpencodeAdapter {
     };
     const { sdk, version: opencodeVersion } = await loadOpencodeSdkImpl();
     let listTools;
-    const host = await sdk.OpenCode.create({
-      config: { content: JSON.stringify(opencodeConfig) },
-      plugins: [
-        createOpencodeSwarmPlugin(swarm, {
-          onToolRegistry: (lister) => {
-            listTools = lister;
-          }
-        })
-      ],
-      log: {
-        level: "warn",
-        emit: (entry) => console.warn(scrubSecrets(`[opencode] ${entry.message}`))
-      }
-    });
+    const billing = config.model.startsWith("openrouter/") ? new OpenRouterBilling : undefined;
+    let host;
+    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;
     try {
       const created = await host.sessions.create({
@@ -660,9 +888,9 @@ class OpencodeAdapter {
       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(host, sessionId, config.model, swarm, config.cwd, appliedReasoningEffort);
+    const session = new OpencodeSession(host, sessionId, config.model, swarm, config.cwd, appliedReasoningEffort, billing);
     session.emitSessionInit(opencodeVersion ? { version: opencodeVersion } : undefined);
     (async () => {
       try {
@@ -703,4 +931,4 @@ class OpencodeAdapter {
   }
 }
 
-export { checkOpencodeCredentials, resolveOpencodeSdkSpecifier, _setOpencodeSdkLoaderForTests, applyOpenRouterBaseUrlOverride, _setOpencodeSessionHooksForTests, checkSwarmMcpAdmission, OpencodeSession, OpencodeAdapter };
+export { checkOpencodeCredentials, resolveOpencodeSdkSpecifier, _setOpencodeSdkLoaderForTests, applyOpenRouterBaseUrlOverride, buildOpenAICompatibleProviderBlock, applyProviderKeySplice, _setOpencodeSessionHooksForTests, checkSwarmMcpAdmission, OpencodeSession, OpencodeAdapter };

package/dist/{cli-04emfe2q.js → cli-vdach5a9.js}

@@ -5,14 +5,14 @@ import {
   CONTEXT_FORMULA,
   clampContextPercent,
   computeContextUsedUnified
-} from "./cli-7avy4v8w.js";
+} from "./cli-w1q7h2r2.js";
 import {
   applyReasoningEffort
-} from "./cli-tmhsxhb8.js";
+} from "./cli-n5vwg842.js";
 import {
   ampBillsCacheWrites,
   resolveAmpModel
-} from "./cli-2bw3w47j.js";
+} from "./cli-hnhtk6cj.js";
 import {
   swarmRuntimeInstanceId
 } from "./cli-re8z5p8p.js";
@@ -28,7 +28,7 @@ import {
   init_secret_scrubber,
   registerVolatileSecret,
   scrubSecrets
-} from "./cli-d161g69q.js";
+} from "./cli-p1x85d2t.js";
 
 // src/providers/amp-adapter.ts
 import { existsSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
@@ -36,7 +36,7 @@ import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 init_secret_scrubber();
-var AMP_PACKAGE = "@ampcode/cli@0.0.1791878731-g2f7fd0";
+var AMP_PACKAGE = "@ampcode/cli@0.0.1792065649-g5a30fc";
 var AMP_MCP_SERVER_NAME = "agent-swarm";
 var AMP_PLUGIN_MODE_KEY = "agent-swarm";
 var AMP_LIVE_TEST_TIMEOUT_MS = 5000;

package/dist/{cli-7avy4v8w.js → cli-w1q7h2r2.js}

@@ -1,10 +1,12 @@
 import {
-  buildClaudeShortnameMap,
   init_runtime_model_catalog,
-  init_src,
   runtimeCatalogModel,
   runtimeCatalogSection
-} from "./cli-014vns2y.js";
+} from "./cli-stfs0k5s.js";
+import {
+  buildClaudeShortnameMap,
+  init_src
+} from "./cli-e3g5mbkz.js";
 
 // src/utils/context-window.ts
 init_src();

package/dist/{cli-rcp5aqdw.js → cli-w7m81tb7.js}

@@ -14,7 +14,7 @@ import {
   require_proper_lockfile,
   resolveConfigValueOrThrow,
   resolveHeadersOrThrow
-} from "./cli-r44t9wqc.js";
+} from "./cli-r106725k.js";
 import {
   APP_NAME,
   VERSION,

package/dist/{cli-hwwvy36w.js → cli-wayw93nt.js}

@@ -1,18 +1,18 @@
 import {
   recordUnmappedIdentity,
   resolveIdentity
-} from "./cli-ztrv9y21.js";
+} from "./cli-bzszjf2p.js";
 import {
   findOrCreateUserByEmail,
   findUserByExternalId,
   init_users,
   linkIdentity
-} from "./cli-e0a9sk00.js";
+} from "./cli-eejsgvm4.js";
 import {
   getKv,
   init_db1 as init_db,
   upsertKv
-} from "./cli-tgpfnm6r.js";
+} from "./cli-ef1hg1wv.js";
 
 // src/slack/enrich.ts
 init_db();