@desplega.ai/agent-swarm 1.158.0 → 1.159.0

package/dist/{cli-j55n64b6.js → cli-bv0a38v9.js}

@@ -1,32 +1,33 @@
-import {
-  renderSteeringDelivery
-} from "./cli-y95wp3tg.js";
-import {
-  checkDevinCredentials
-} from "./cli-9b13ggd1.js";
-import {
-  checkOpencodeCredentials
-} from "./cli-1hkrch3k.js";
 import {
   checkDshCredentials
-} from "./cli-5d10vd2m.js";
+} from "./cli-e0ndxhtk.js";
+import {
+  renderSteeringDelivery
+} from "./cli-96qd5psa.js";
 import {
   checkCodexCredentials,
   codexUserHome
-} from "./cli-20cj37vt.js";
+} from "./cli-xgpf00sk.js";
 import {
   checkClaudeManagedCredentials
-} from "./cli-68w09sjw.js";
+} from "./cli-vn0qv9cj.js";
 import {
+  checkDevinCredentials
+} from "./cli-9b13ggd1.js";
+import {
+  checkOpencodeCredentials
+} from "./cli-zw65mab6.js";
+import {
+  isUnknownModelError,
   renderMemoriesPrompt,
   writeSkillsToFilesystem
-} from "./cli-q67y4wzm.js";
+} from "./cli-phsaj4xq.js";
 import {
   checkClaudeCredentials
-} from "./cli-7gtvvpbh.js";
+} from "./cli-4tvgz99m.js";
 import {
   getContextWindowSize
-} from "./cli-0xjkj1j7.js";
+} from "./cli-wd9hz40d.js";
 import {
   CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS,
   MAX_RATE_LIMIT_RESET_MS,
@@ -38,7 +39,16 @@ import {
 import {
   resolveScriptsOnlyMode,
   validateJsonSchema
-} from "./cli-ftfvggzx.js";
+} from "./cli-79aq9cgb.js";
+import {
+  refreshRuntimeModelCatalog
+} from "./cli-m4excttz.js";
+import {
+  terminateRegisteredProcessGroups
+} from "./cli-y89t4nca.js";
+import {
+  getApiKey
+} from "./cli-f14fvzag.js";
 import {
   authJsonToCredentialSelection,
   credentialsToAuthJson,
@@ -47,12 +57,6 @@ import {
 import {
   getOpenRouterBaseUrl
 } from "./cli-3dpj7atn.js";
-import {
-  terminateRegisteredProcessGroups
-} from "./cli-y89t4nca.js";
-import {
-  getApiKey
-} from "./cli-f14fvzag.js";
 import {
   buildContextPreamble,
   buildResumeContextPreamble,
@@ -65,7 +69,7 @@ import {
   syncProfileFilesToServer,
   writeIdentityBaselines,
   writeProfileFileFromDb
-} from "./cli-xberxa1r.js";
+} from "./cli-10ym38qc.js";
 import {
   ensure,
   initOtel,
@@ -75,7 +79,7 @@ import {
   startSpan,
   withSpan,
   withSpanContext
-} from "./cli-j57qkrpq.js";
+} from "./cli-wgjx0q33.js";
 import {
   init_task_attachment_links,
   taskAttachmentFetchCommand
@@ -84,12 +88,13 @@ import {
   initTelemetry,
   init_telemetry,
   telemetry
-} from "./cli-47m6dkd3.js";
+} from "./cli-g9df2m37.js";
 import {
   ProviderNameSchema,
   init_types,
+  parseWorkerModelTierOverrides,
   resolveTaskModelSelection
-} from "./cli-4198qc9v.js";
+} from "./cli-e4xnc0qp.js";
 import {
   generateDefaultClaudeMd,
   generateDefaultIdentityMd,
@@ -99,7 +104,7 @@ import {
   init_base_prompt,
   init_defaults,
   init_templates
-} from "./cli-3gmcwfyx.js";
+} from "./cli-ardpzhjm.js";
 import {
   configureHttpResolver,
   init_resolver,
@@ -108,16 +113,16 @@ import {
   interpolate,
   isSteeringEnabled,
   resolveTemplateAsync
-} from "./cli-ggm92wcn.js";
+} from "./cli-rgjprct3.js";
+import {
+  getMcpBaseUrl,
+  init_constants
+} from "./cli-dv6cdjs2.js";
 import {
   ModelWindowExhaustedError,
   init_credentials,
   resolveCredentialPools
 } from "./cli-19jenss3.js";
-import {
-  getMcpBaseUrl,
-  init_constants
-} from "./cli-dv6cdjs2.js";
 import {
   init_model_rate_limit_windows,
   parseModelLimitMessage,
@@ -163,19 +168,19 @@ async function materializeCodexAuthJson(_slot, creds, deps = {}) {
 async function createProviderAdapter(provider) {
   switch (provider) {
     case "claude": {
-      const { ClaudeAdapter } = await import("./claude-adapter-tv2x4f36.js");
+      const { ClaudeAdapter } = await import("./claude-adapter-1t6611ne.js");
       return new ClaudeAdapter;
     }
     case "pi": {
-      const { PiMonoAdapter } = await import("./pi-mono-adapter-m6dvv0dz.js");
+      const { PiMonoAdapter } = await import("./pi-mono-adapter-n0me28wt.js");
       return new PiMonoAdapter;
     }
     case "codex": {
-      const { CodexAdapter } = await import("./codex-adapter-cnm8wk11.js");
+      const { CodexAdapter } = await import("./codex-adapter-jqfqqa21.js");
       return new CodexAdapter;
     }
     case "claude-managed": {
-      const { ClaudeManagedAdapter } = await import("./claude-managed-adapter-41b2s7fd.js");
+      const { ClaudeManagedAdapter } = await import("./claude-managed-adapter-werp659j.js");
       return new ClaudeManagedAdapter;
     }
     case "devin": {
@@ -183,15 +188,15 @@ async function createProviderAdapter(provider) {
       return new DevinAdapter;
     }
     case "opencode": {
-      const { OpencodeAdapter } = await import("./opencode-adapter-x6x2da1z.js");
+      const { OpencodeAdapter } = await import("./opencode-adapter-zz7xvjj6.js");
       return new OpencodeAdapter;
     }
     case "dsh": {
-      const { DshAdapter } = await import("./dsh-adapter-k03nfqa6.js");
+      const { DshAdapter } = await import("./dsh-adapter-894mgfvs.js");
       return new DshAdapter;
     }
     case "acp": {
-      const { ACPAdapter } = await import("./acp-adapter-xaq4n6pc.js");
+      const { ACPAdapter } = await import("./acp-adapter-qhch0n2v.js");
       return new ACPAdapter;
     }
     default:
@@ -216,6 +221,82 @@ function computeBudgetBackoffMs(consecutiveRefusals, basePollMs) {
 init_constants();
 init_credentials();
 
+// src/utils/harness-cli-version.ts
+init_secret_scrubber();
+var CLI_BINARY = { claude: "claude", codex: "codex" };
+var PROBE_TIMEOUT_MS = 1e4;
+var VERSION_RE = /\d+\.\d+\.\d+(?:[-+][\w.]+)?/;
+var probed = new Map;
+function parseCliVersion(output) {
+  return VERSION_RE.exec(output)?.[0] ?? null;
+}
+function probeHarnessCliVersion(harness) {
+  const binary = CLI_BINARY[harness];
+  if (!binary)
+    return Promise.resolve(null);
+  let pending = probed.get(harness);
+  if (!pending) {
+    pending = (async () => {
+      try {
+        const proc = Bun.spawn([binary, "--version"], {
+          stdin: "ignore",
+          stdout: "pipe",
+          stderr: "pipe",
+          timeout: PROBE_TIMEOUT_MS,
+          killSignal: "SIGKILL"
+        });
+        const [stdout, exitCode] = await Promise.all([
+          new Response(proc.stdout).text(),
+          proc.exited
+        ]);
+        return exitCode === 0 ? parseCliVersion(stdout) : null;
+      } catch {
+        return null;
+      }
+    })();
+    probed.set(harness, pending);
+  }
+  return pending;
+}
+async function cachedHarnessCliVersion(harness) {
+  return await probed.get(harness) ?? null;
+}
+var reported = new Set;
+async function reportHarnessModelOutcome(opts) {
+  if (!opts.model || !CLI_BINARY[opts.harness])
+    return;
+  const cliVersion = await cachedHarnessCliVersion(opts.harness);
+  if (!cliVersion)
+    return;
+  const status = opts.exitCode === 0 ? "ok" : isUnknownModelError(opts.failureReason, opts.model) ? "unsupported" : null;
+  if (!status)
+    return;
+  const key = `${opts.harness}|${cliVersion}|${opts.model}`;
+  if (status === "ok" && reported.has(key))
+    return;
+  try {
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Agent-ID": opts.agentId
+    };
+    if (opts.apiKey)
+      headers.Authorization = `Bearer ${opts.apiKey}`;
+    const res = await (opts.fetchImpl ?? fetch)(`${opts.apiUrl}/api/models-catalog/harness-support`, {
+      method: "PUT",
+      headers,
+      body: JSON.stringify({
+        harness: opts.harness,
+        cliVersion,
+        modelId: opts.model,
+        status,
+        ...status === "unsupported" && opts.failureReason ? { error: scrubSecrets(opts.failureReason).slice(0, 2000) } : {}
+      })
+    });
+    if (res.ok && status === "ok")
+      reported.add(key);
+  } catch {}
+}
+
 // src/utils/harness-provider.ts
 init_types();
 var SUPPORTED_PROVIDERS = ProviderNameSchema.options;
@@ -605,7 +686,7 @@ var CREDENTIAL_PROVIDER_CHECKERS = {
   devin: (env) => checkDevinCredentials(env),
   opencode: (env, opts) => checkOpencodeCredentials(env, opts),
   pi: async (env, opts) => {
-    const { checkPiMonoCredentials } = await import("./pi-mono-adapter-m6dvv0dz.js");
+    const { checkPiMonoCredentials } = await import("./pi-mono-adapter-n0me28wt.js");
     return checkPiMonoCredentials(env, opts);
   },
   acp: () => ({ ready: true, missing: [], satisfiedBy: "sdk-delegated" })
@@ -1769,6 +1850,8 @@ var SWARM_TOOL_LABELS = {
   "set-config": "⚙️ Setting config",
   "list-config": "⚙️ Listing config",
   "delete-config": "⚙️ Deleting config",
+  "model-catalog-refresh": "\uD83E\uDDE0 Refreshing model catalog",
+  "model-catalog-overlay-upsert": "\uD83E\uDDE0 Updating model catalog overlay",
   "create-schedule": "\uD83D\uDCC5 Creating schedule",
   "list-schedules": "\uD83D\uDCC5 Listing schedules",
   "run-schedule-now": "\uD83D\uDCC5 Running schedule",
@@ -2705,6 +2788,9 @@ async function triggerHeartbeatSweep(config) {
     return false;
   }
 }
+function workerModelTierOverrides(provider) {
+  return parseWorkerModelTierOverrides(process.env, provider);
+}
 async function buildRequesterProfilePrompt(requestedBy) {
   const comms = requestedBy?.comms;
   const commsParts = [
@@ -2749,7 +2835,9 @@ async function registerAgent(opts) {
       maxTasks: opts.maxTasks,
       provider,
       harness_provider: harnessProvider,
-      runtimeInstanceId: opts.runtimeInstanceId
+      runtimeInstanceId: opts.runtimeInstanceId,
+      modelTierOverrides: workerModelTierOverrides(harnessProvider),
+      harnessCliVersion: await probeHarnessCliVersion(harnessProvider) ?? undefined
     })
   });
   if (!response.ok) {
@@ -2781,6 +2869,11 @@ async function pollForTrigger(opts) {
 }
 async function pollForTriggerOnce(opts) {
   const startTime = Date.now();
+  refreshRuntimeModelCatalog({
+    apiUrl: opts.apiUrl,
+    apiKey: opts.apiKey,
+    agentId: opts.agentId
+  });
   const headers = {
     "X-Agent-ID": opts.agentId
   };
@@ -2791,6 +2884,9 @@ async function pollForTriggerOnce(opts) {
     headers.Authorization = `Bearer ${opts.apiKey}`;
   }
   injectTraceContext(headers);
+  if (opts.harnessProvider) {
+    headers["X-Model-Tier-Overrides"] = encodeURIComponent(JSON.stringify(workerModelTierOverrides(opts.harnessProvider)));
+  }
   while (Date.now() - startTime < opts.pollTimeout) {
     try {
       let url = `${opts.apiUrl}/api/poll`;
@@ -3133,7 +3229,7 @@ async function spawnProviderProcess(adapter, opts, logDir, isYolo) {
   let freshEnv;
   let credentialSelections;
   try {
-    ({ env: freshEnv, credentialSelections } = await fetchResolvedEnv(opts.apiUrl, opts.apiKey, opts.agentId, process.env, opts.model, {
+    ({ env: freshEnv, credentialSelections } = await fetchResolvedEnv(opts.apiUrl, opts.apiKey, opts.agentId, process.env, opts.resolvedModel || opts.model, {
       repoId: sessionRepo?.id,
       provider: adapter.name,
       modelTier: opts.modelTier,
@@ -3166,7 +3262,10 @@ async function spawnProviderProcess(adapter, opts, logDir, isYolo) {
     harnessProvider: opts.harnessProvider,
     env: freshEnv
   });
-  const taskModel = taskModelSelection.model || "";
+  if (opts.resolvedModel && taskModelSelection.model && taskModelSelection.model !== opts.resolvedModel) {
+    console.log(`[${opts.role}] model resolution mismatch for task ${opts.taskId ?? "?"}: server=${opts.resolvedModel} (${opts.modelSource ?? "?"}) local=${taskModelSelection.model}; using server value`);
+  }
+  const taskModel = opts.resolvedModel || taskModelSelection.model || "";
   const model = taskModel || configModel || "";
   let oauthSelection;
   let oauthIsPoolBacked = false;
@@ -3777,6 +3876,15 @@ async function checkCompletedProcesses(state, role, apiConfig, cancelledSignaled
         failureReason = result.failureReason;
         console.log(`[${role}] Detected error for task ${taskId.slice(0, 8)}: ${failureReason}`);
       }
+      reportHarnessModelOutcome({
+        apiUrl: apiConfig.apiUrl,
+        apiKey: apiConfig.apiKey,
+        agentId: apiConfig.agentId,
+        harness: harnessProvider,
+        model,
+        exitCode: result.exitCode,
+        failureReason
+      });
       if (credentialInfo) {
         const outcome = classifyRateLimitOutcome(result, failureReason, Date.now(), state.codexCreditsExhaustedCooldownMs);
         const keyRateLimitedUntil = outcome.kind === "key" ? outcome.rateLimitedUntil : outcome.kind === "model" ? outcome.keyRateLimitedUntil : undefined;
@@ -4664,6 +4772,8 @@ ${additionalSystemPrompt}` : basePrompt;
             taskId: task.id,
             model: task.model,
             modelTier: task.modelTier,
+            resolvedModel: task.resolvedModel,
+            modelSource: task.modelSource,
             effort: task.effort,
             harnessProvider: state.harnessProvider,
             cwd: resumeCwd,
@@ -4782,7 +4892,8 @@ ${additionalSystemPrompt}` : basePrompt;
         agentId,
         pollInterval: PollIntervalMs,
         runtimeInstanceId,
-        pollTimeout: effectiveTimeout
+        pollTimeout: effectiveTimeout,
+        harnessProvider: state.harnessProvider
       });
       if (trigger) {
         if (trigger.type === "budget_refused") {
@@ -4958,6 +5069,12 @@ Note: The task requested working directory "${taskDir}" but it does not exist. F
 
 `);
         const taskSystemPrompt = taskPromptParts + cwdWarning;
+        const modelUnsupported = trigger.task?.modelUnsupported;
+        if (trigger.taskId && modelUnsupported) {
+          console.log(`[${role}] ${modelUnsupported}`);
+          await ensureTaskFinished(apiConfig, role, trigger.taskId, 1, modelUnsupported);
+          continue;
+        }
         iteration++;
         const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
         const taskIdSlice = trigger.taskId?.slice(0, 8) || "notask";
@@ -5007,6 +5124,8 @@ Note: The task requested working directory "${taskDir}" but it does not exist. F
             taskId: trigger.taskId,
             model: taskModel,
             modelTier: taskModelTier,
+            resolvedModel: trigger.task?.resolvedModel,
+            modelSource: trigger.task?.modelSource,
             effort: taskEffort,
             harnessProvider: state.harnessProvider,
             cwd: effectiveCwd,

package/dist/cli-ca2w7zv7.js

@@ -0,0 +1,115 @@
+import {
+  runtimeCatalogModel,
+  runtimeCatalogSection
+} from "./cli-m4excttz.js";
+import {
+  claudeCatalogModelId,
+  init_src,
+  reasoningLevelsFor
+} from "./cli-7zttzetj.js";
+
+// src/providers/reasoning-effort.ts
+init_src();
+function splitProviderModel(model) {
+  const slash = model.indexOf("/");
+  if (slash === -1)
+    return { providerId: "", modelId: model };
+  return { providerId: model.slice(0, slash), modelId: model.slice(slash + 1) };
+}
+function lookupModel(harness, model) {
+  if (!model)
+    return;
+  let providerId;
+  let modelId;
+  if (harness === "claude") {
+    providerId = "anthropic";
+    modelId = claudeCatalogModelId(model, runtimeCatalogSection("anthropic"));
+  } else if (harness === "codex") {
+    providerId = "openai";
+    modelId = model;
+  } else {
+    ({ providerId, modelId } = splitProviderModel(model));
+    if (!providerId)
+      return;
+  }
+  const facts = runtimeCatalogModel(providerId, modelId);
+  return facts ? { id: modelId, facts } : undefined;
+}
+function pickDefault(levels) {
+  if (levels.length === 0)
+    return null;
+  return levels.includes("medium") ? "medium" : levels[0] ?? null;
+}
+function reasoningCapability(harness, model) {
+  const entry = lookupModel(harness, model);
+  const levels = entry ? reasoningLevelsFor(harness, entry.id, entry.facts) : [];
+  if (levels.length === 0)
+    return { supported: false, levels: [], default: null };
+  return { supported: true, levels, default: pickDefault(levels) };
+}
+function applyClaudeEffort(level) {
+  if (level === "off") {
+    return { kind: "claude-env", env: { MAX_THINKING_TOKENS: "0" } };
+  }
+  return { kind: "claude-env", env: { CLAUDE_CODE_EFFORT_LEVEL: level } };
+}
+function applyCodexEffort(level) {
+  const value = level === "off" ? "none" : level;
+  return { kind: "codex-config", config: { model_reasoning_effort: value } };
+}
+function applyPiEffort(level) {
+  return { kind: "pi-session", sessionOptions: { thinkingLevel: level } };
+}
+var ANTHROPIC_BUDGET_TOKENS_BY_LEVEL = {
+  low: 4096,
+  medium: 10240,
+  high: 32768,
+  xhigh: 65536
+};
+function buildOpencodeReasoningOptions(providerId, level) {
+  if (providerId === "anthropic") {
+    if (level === "max")
+      return { reasoningEffort: level };
+    return { thinking: { type: "enabled", budgetTokens: ANTHROPIC_BUDGET_TOKENS_BY_LEVEL[level] } };
+  }
+  if (providerId === "openrouter") {
+    return { reasoning: { effort: level } };
+  }
+  return { reasoningEffort: level };
+}
+function applyOpencodeEffort(model, level) {
+  if (level === "off") {
+    return { kind: "noop" };
+  }
+  const { providerId, modelId } = splitProviderModel(model);
+  return {
+    kind: "opencode-options",
+    providerId,
+    modelId,
+    options: buildOpencodeReasoningOptions(providerId, level)
+  };
+}
+function applyReasoningEffort(harness, model, level) {
+  if (level === undefined)
+    return { kind: "noop" };
+  const capability = reasoningCapability(harness, model);
+  if (!capability.supported || !capability.levels.includes(level)) {
+    return { kind: "noop" };
+  }
+  switch (harness) {
+    case "claude":
+      return applyClaudeEffort(level);
+    case "codex":
+      return applyCodexEffort(level);
+    case "pi":
+      return applyPiEffort(level);
+    case "opencode":
+      return applyOpencodeEffort(model, level);
+    default: {
+      const _exhaustive = harness;
+      return _exhaustive;
+    }
+  }
+}
+
+export { reasoningCapability, applyReasoningEffort };