@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/dist/{cli-g4f5pj26.js → cli-q0ke1yww.js}

@@ -1,13 +1,13 @@
 import {
   runStopHookSessionSummarySubprocess
-} from "./cli-g6t9texm.js";
+} from "./cli-m50t4309.js";
+import {
+  fetchInstalledMcpServers
+} from "./cli-tng3131n.js";
 import {
   buildOtelTraceparentEnv,
   isHarnessOtelEnabled
 } from "./cli-q2j38vre.js";
-import {
-  fetchInstalledMcpServers
-} from "./cli-tng3131n.js";
 import {
   CTX_MODE_NUDGE_EVERY
 } from "./cli-zm7njwzd.js";
@@ -19,7 +19,7 @@ import {
   clampContextPercent,
   computeContextUsedUnified,
   getContextWindowSize
-} from "./cli-7avy4v8w.js";
+} from "./cli-w1q7h2r2.js";
 import {
   isClaudeBridgeEffective,
   resolveClaudeTransport
@@ -32,7 +32,7 @@ import {
 } from "./cli-2pdaysab.js";
 import {
   applyReasoningEffort
-} from "./cli-tmhsxhb8.js";
+} from "./cli-n5vwg842.js";
 import {
   require_src
 } from "./cli-knd276ed.js";
@@ -47,12 +47,12 @@ import {
 import {
   init_file_lock,
   withFileLock
-} from "./cli-nyhb1r6x.js";
+} from "./cli-s2sp957d.js";
 import {
   CLAUDE_CREDENTIALS_HINT,
   init_credentials,
   validateClaudeCredentials
-} from "./cli-tadfgd0t.js";
+} from "./cli-5hkm7whv.js";
 import {
   deriveDefaultRoute,
   init_src,
@@ -70,7 +70,7 @@ import {
 import {
   init_secret_scrubber,
   scrubSecrets
-} from "./cli-d161g69q.js";
+} from "./cli-p1x85d2t.js";
 import {
   __require,
   __toESM
@@ -93,8 +93,8 @@ import {
   utimes,
   writeFile
 } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { dirname, join as join2, resolve as resolve2 } from "node:path";
 import { promisify } from "node:util";
 init_credentials();
 init_env_flag();
@@ -167,6 +167,80 @@ class ClaudeBackgroundKeepalive {
   }
 }
 
+// src/providers/claude-flag-settings.ts
+init_secret_scrubber();
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+var WORKSPACE_CLAUDE_MD_EXCLUDE = "/workspace/CLAUDE.md";
+function userClaudeMdExclude(home = process.env.HOME ?? homedir()) {
+  return join(home, ".claude", "CLAUDE.md");
+}
+function claudeFlagSettings() {
+  return { claudeMdExcludes: [WORKSPACE_CLAUDE_MD_EXCLUDE, userClaudeMdExclude()] };
+}
+var SETTINGS_FLAG = "--settings";
+
+class ClaudeSettingsConfigError extends Error {
+  constructor(detail) {
+    super(scrubSecrets(`Invalid caller --settings: ${detail}. Refusing to start Claude without the caller's settings.`));
+    this.name = "ClaudeSettingsConfigError";
+  }
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseCallerSettings(value, cwd) {
+  const inline = value.trimStart().startsWith("{");
+  const source = inline ? "inline JSON" : `file ${resolve(cwd, value)}`;
+  let parsed;
+  try {
+    parsed = JSON.parse(inline ? value : readFileSync(resolve(cwd, value), "utf8"));
+  } catch (err) {
+    const code = err.code;
+    throw new ClaudeSettingsConfigError(`${source} ${inline || !code ? "is not valid JSON" : `cannot be read (${code})`}`);
+  }
+  if (!isPlainObject(parsed)) {
+    throw new ClaudeSettingsConfigError(`${source} is not a JSON object`);
+  }
+  return parsed;
+}
+function mergeClaudeSettingsArgs(argLists, cwd) {
+  const merged = {};
+  const excludes = new Set;
+  const absorb = (value) => {
+    if (!value)
+      throw new ClaudeSettingsConfigError("--settings has no value");
+    const parsed = parseCallerSettings(value, cwd);
+    Object.assign(merged, parsed);
+    if (Array.isArray(parsed.claudeMdExcludes)) {
+      for (const entry of parsed.claudeMdExcludes) {
+        if (typeof entry === "string")
+          excludes.add(entry);
+      }
+    }
+  };
+  const stripped = argLists.map((args) => {
+    const passthrough = [];
+    for (let i = 0;i < args.length; i++) {
+      const arg = args[i] ?? "";
+      if (arg === SETTINGS_FLAG) {
+        const value = args[i + 1];
+        absorb(value?.startsWith("-") ? undefined : value);
+        i++;
+      } else if (arg.startsWith(`${SETTINGS_FLAG}=`)) {
+        absorb(arg.slice(SETTINGS_FLAG.length + 1));
+      } else {
+        passthrough.push(arg);
+      }
+    }
+    return passthrough;
+  });
+  for (const entry of claudeFlagSettings().claudeMdExcludes)
+    excludes.add(entry);
+  return { argLists: stripped, settings: { ...merged, claudeMdExcludes: [...excludes] } };
+}
+
 // src/providers/claude-session-events.ts
 init_secret_scrubber();
 function finiteNumber(value) {
@@ -216,7 +290,7 @@ function costFromResult(json, state) {
     cacheWriteTokens: usage?.cache_creation_input_tokens ?? 0,
     cacheWrite5mTokens: finiteNumber(cacheCreation?.ephemeral_5m_input_tokens),
     cacheWrite1hTokens: finiteNumber(cacheCreation?.ephemeral_1h_input_tokens),
-    thinkingTokens: usage?.thinking_input_tokens ?? 0,
+    thinkingTokens: tokenCount(usage?.output_tokens_details?.thinking_tokens) ?? tokenCount(usage?.thinking_input_tokens) ?? 0,
     models,
     durationMs: json.duration_ms || 0,
     numTurns: json.num_turns ?? null,
@@ -450,8 +524,8 @@ function withClaudeBridgeAuthArgs(argv, sourceEnv) {
   return [...argv];
 }
 var execFileAsync = promisify(execFile);
-async function preseedClaudeTrustDialog(dirs, homeDir = process.env.HOME ?? homedir()) {
-  const claudeJsonPath = join(homeDir, ".claude.json");
+async function preseedClaudeTrustDialog(dirs, homeDir = process.env.HOME ?? homedir2()) {
+  const claudeJsonPath = join2(homeDir, ".claude.json");
   const seed = async () => {
     for (let attempt = 1;; attempt++) {
       await withClaudeJsonLock(claudeJsonPath, () => seedTrustLocked(claudeJsonPath, dirs));
@@ -593,9 +667,9 @@ async function resolveClaudeTrustDirs(cwd) {
         "core.worktree"
       ]).then((r) => r.stdout.trim(), () => "");
       if (configured)
-        main = resolve(path, configured);
+        main = resolve2(path, configured);
       main = await realpath(main);
-      if (await stat(join(main, ".git")).then(() => true, () => false)) {
+      if (await stat(join2(main, ".git")).then(() => true, () => false)) {
         if (!dirs.includes(main))
           dirs.push(main);
       }
@@ -631,7 +705,7 @@ async function createSessionMcpConfig(cwd, taskId, installedServers, contextKey)
   const mcpJsonPaths = [];
   let searchDir = cwd;
   while (true) {
-    const candidate = join(searchDir, ".mcp.json");
+    const candidate = join2(searchDir, ".mcp.json");
     if (await Bun.file(candidate).exists()) {
       mcpJsonPaths.push(candidate);
     }
@@ -762,7 +836,7 @@ function getSystemPromptFilePath(taskId) {
 async function resolveClaudePrompt(prompt, home, onInline) {
   const resolved = await resolveSlashSkillPrompt(prompt, {
     providerLabel: "claude",
-    skillsDir: join(home, ".claude", "skills"),
+    skillsDir: join2(home, ".claude", "skills"),
     stripFrontmatter: true,
     emit: (event) => {
       if (event.type === "raw_stderr")
@@ -782,6 +856,7 @@ class ClaudeSession {
   harnessVariantMeta;
   queueSteeringSupported;
   runSessionSummary;
+  flagSettings;
   proc;
   stdinWriter;
   listeners = [];
@@ -797,7 +872,7 @@ class ClaudeSession {
   transcript;
   backgroundKeepalive;
   deliverSteering;
-  constructor(config, model, taskFilePath, taskFileKey, sessionMcpConfig = null, claudeBinaryArgv = ["claude"], systemPromptFile = null, harnessVariant, harnessVariantMeta, queueSteeringSupported = false, runSessionSummary = runStopHookSessionSummarySubprocess) {
+  constructor(config, model, taskFilePath, taskFileKey, sessionMcpConfig = null, claudeBinaryArgv = ["claude"], systemPromptFile = null, harnessVariant, harnessVariantMeta, queueSteeringSupported = false, runSessionSummary = runStopHookSessionSummarySubprocess, flagSettings = claudeFlagSettings()) {
     this.config = config;
     this.model = model;
     this.sessionMcpConfig = sessionMcpConfig;
@@ -806,6 +881,7 @@ class ClaudeSession {
     this.harnessVariantMeta = harnessVariantMeta;
     this.queueSteeringSupported = queueSteeringSupported;
     this.runSessionSummary = runSessionSummary;
+    this.flagSettings = flagSettings;
     this.taskFileKey = taskFileKey;
     this.contextWindowSize = getContextWindowSize(model);
     this.systemPromptFile = systemPromptFile;
@@ -885,7 +961,9 @@ class ClaudeSession {
       "--dangerously-skip-permissions",
       "--allow-dangerously-skip-permissions",
       "--permission-mode",
-      "bypassPermissions"
+      "bypassPermissions",
+      "--settings",
+      JSON.stringify(this.flagSettings)
     ];
     if (this.queueSteeringSupported) {
       cmd.push("--input-format", "stream-json");
@@ -1102,7 +1180,7 @@ class ClaudeAdapter {
     const sourceEnv = withClaudeRouteEnv(config.env || process.env);
     const sessionConfig = {
       ...config,
-      prompt: await resolveClaudePrompt(config.prompt, process.env.HOME ?? homedir(), config.onPromptSkill)
+      prompt: await resolveClaudePrompt(config.prompt, process.env.HOME ?? homedir2(), config.onPromptSkill)
     };
     const transport = resolveClaudeTransport(sourceEnv);
     const credType = validateClaudeCredentials(sourceEnv);
@@ -1116,7 +1194,7 @@ class ClaudeAdapter {
     if (transport === "sdk" && isClaudeBridgeEffective(sourceEnv)) {
       throw new Error("CLAUDE_TRANSPORT=sdk cannot run with an effective Claude Bridge configuration. Select CLI transport or disable the bridge.");
     }
-    const claudeSdk = transport === "sdk" ? await import("./claude-sdk-session-gsfsh662.js") : undefined;
+    const claudeSdk = transport === "sdk" ? await import("./claude-sdk-session-9jye6cxr.js") : undefined;
     claudeSdk?.validateClaudeSdkAdditionalArgs([
       ...claudeBinaryArgv.slice(1),
       ...config.additionalArgs ?? []
@@ -1125,7 +1203,14 @@ class ClaudeAdapter {
       console.warn(`\x1B[33m[claude]\x1B[0m SWARM_USE_CLAUDE_BRIDGE is set but no CLAUDE_CODE_OAUTH_TOKEN is present — falling back to stock 'claude'. claude-bridge requires a subscription/OAuth token (it forwards only the OAuth token to claude and strips ANTHROPIC_*); API-key billing is identical headless vs interactive, so the bridge isn't needed.`);
     }
     const isLegacyBridgeCompat = isLegacyClaudeBridgeCompatBinary(claudeBinaryRaw);
-    const effectiveClaudeBinaryArgv = useClaudeBridge ? withClaudeBridgeAuthArgs(claudeBinaryArgv, sourceEnv) : claudeBinaryArgv;
+    const [claudeExecutable = "claude", ...claudePrefixArgs] = useClaudeBridge ? withClaudeBridgeAuthArgs(claudeBinaryArgv, sourceEnv) : claudeBinaryArgv;
+    const {
+      argLists: [prefixArgs = [], additionalArgs = []],
+      settings: flagSettings
+    } = mergeClaudeSettingsArgs([claudePrefixArgs, config.additionalArgs ?? []], config.cwd);
+    const effectiveClaudeBinaryArgv = [claudeExecutable, ...prefixArgs];
+    sessionConfig.additionalArgs = additionalArgs;
+    const flagSettingsArgs = ["--settings", JSON.stringify(flagSettings)];
     const isInteractiveTmuxClaude = isLegacyBridgeCompat || useClaudeBridge;
     const configuredClaudeBinaryRaw = resolveClaudeBinary(sourceEnv);
     if (isLegacyClaudeBridgeCompatBinary(configuredClaudeBinaryRaw)) {
@@ -1170,7 +1255,7 @@ class ClaudeAdapter {
     const queueSteeringOverride = resolveClaudeQueueSteeringOverride(sourceEnv);
     let harnessVersion;
     try {
-      const probe = registerProcessGroup(Bun.spawn([...effectiveClaudeBinaryArgv, "--version"], {
+      const probe = registerProcessGroup(Bun.spawn([...effectiveClaudeBinaryArgv, ...flagSettingsArgs, "--version"], {
         detached: detachedProcessGroup,
         env: sourceEnv,
         stdin: "ignore",
@@ -1206,6 +1291,7 @@ ${stderr}`.trim();
         taskFileKey,
         sessionMcpConfig,
         claudeBinaryArgv: effectiveClaudeBinaryArgv,
+        settings: flagSettings,
         systemPromptFile,
         harnessVariant,
         harnessVariantMeta,
@@ -1213,7 +1299,7 @@ ${stderr}`.trim();
         runSessionSummary: this.runSessionSummary
       });
     }
-    return new ClaudeSession(sessionConfig, model, taskFilePath, taskFileKey, sessionMcpConfig, effectiveClaudeBinaryArgv, systemPromptFile, harnessVariant, harnessVariantMeta, queueSteeringSupported, this.runSessionSummary);
+    return new ClaudeSession(sessionConfig, model, taskFilePath, taskFileKey, sessionMcpConfig, effectiveClaudeBinaryArgv, systemPromptFile, harnessVariant, harnessVariantMeta, queueSteeringSupported, this.runSessionSummary, flagSettings);
   }
   async canResume(_sessionId) {
     return true;

package/dist/{cli-e3pmyt39.js → cli-q50942rs.js}

@@ -1,7 +1,7 @@
 import {
   init_secret_scrubber,
   scrubSecrets
-} from "./cli-d161g69q.js";
+} from "./cli-p1x85d2t.js";
 
 // src/providers/devin-adapter.ts
 init_secret_scrubber();

package/dist/{cli-r44t9wqc.js → cli-r106725k.js}

@@ -795,7 +795,7 @@ GFS4: `);
   }
 });
 
-// node_modules/retry/lib/retry_operation.js
+// node_modules/proper-lockfile/node_modules/retry/lib/retry_operation.js
 var require_retry_operation = __commonJS(function(exports, module) {
   function RetryOperation(timeouts, options) {
     if (typeof options === "boolean") {
@@ -924,7 +924,7 @@ var require_retry_operation = __commonJS(function(exports, module) {
   };
 });
 
-// node_modules/retry/lib/retry.js
+// node_modules/proper-lockfile/node_modules/retry/lib/retry.js
 var require_retry = __commonJS(function(exports) {
   var RetryOperation = require_retry_operation();
   exports.operation = function(options) {

package/dist/{cli-gj81e47t.js → cli-r2pnvj8g.js}

@@ -6,11 +6,11 @@ import {
   getSwarmConfigs,
   init_db1 as init_db,
   upsertSwarmConfig
-} from "./cli-tgpfnm6r.js";
+} from "./cli-ef1hg1wv.js";
 import {
   init_secret_scrubber,
   scrubSecrets
-} from "./cli-d161g69q.js";
+} from "./cli-p1x85d2t.js";
 import {
   __require
 } from "./cli-bc05qbss.js";

package/dist/{cli-r8smj8b8.js → cli-r62a35ea.js}

@@ -1,12 +1,19 @@
 import {
   getDb,
   init_db1 as init_db
-} from "./cli-tgpfnm6r.js";
+} from "./cli-ef1hg1wv.js";
+import {
+  init_src,
+  openAICompatibleProviderIds,
+  withRegistryCatalogSections
+} from "./cli-e3g5mbkz.js";
 
 // src/be/seed-pricing.ts
+init_src();
 init_db();
 
 // src/be/modelsdev-cache.ts
+init_src();
 import { readFileSync } from "node:fs";
 import path from "node:path";
 var MODELSDEV_CACHE_PATH = path.join("src", "be", "modelsdev-cache.json");
@@ -24,7 +31,7 @@ function loadModelsDevCache() {
     if (memoized)
       return memoized;
     try {
-      const parsed = JSON.parse(readFileSync(candidate, "utf-8"));
+      const parsed = withRegistryCatalogSections(JSON.parse(readFileSync(candidate, "utf-8")));
       parsedCaches.set(candidate, new WeakRef(parsed));
       return parsed;
     } catch {}
@@ -108,7 +115,7 @@ var ANTHROPIC_SHORTNAME_TO_MODELSDEV = {
 };
 var ANTHROPIC_SHORTNAME_PRICING_FALLBACKS = {
   "claude-opus-5-5": { input: 4, output: 20, cache_read: 0.2, cache_write: 5 },
-  "claude-sonnet-5-5": { input: 2, output: 10, cache_read: 0.2, cache_write: 2.5 },
+  "claude-sonnet-5-5": { input: 2, output: 10, cache_read: 0.1, cache_write: 2.5 },
   "claude-fable-5-1": { input: 10, output: 50, cache_read: 0.25, cache_write: 12.5 },
   "claude-mythos-5-1": { input: 10, output: 50, cache_read: 0.25, cache_write: 12.5 }
 };
@@ -261,6 +268,15 @@ function buildModelsDevSeedRows(cache) {
       add(id, projectCostBlock("gemini", id, model.cost));
     }
   }
+  for (const provider of openAICompatibleProviderIds()) {
+    for (const [id, model] of Object.entries(cache[provider]?.models ?? {})) {
+      if (!model?.cost)
+        continue;
+      const key = `${provider}/${id}`;
+      add(key, projectCostBlock("pi", key, model.cost));
+      add(key, projectCostBlock("opencode", key, model.cost));
+    }
+  }
   return collapseNormalizedIds(sourced);
 }
 function buildPricingSeedRows(cache) {

package/dist/{cli-cd0hv9nh.js → cli-ra0xzggj.js}

@@ -14,11 +14,11 @@ async function createRuntimeProvider(kind, target = {}) {
       return new StaticRuntimeProvider;
     }
     case "docker": {
-      const { DockerRuntimeProvider } = await import("./docker-f503k9p0.js");
+      const { DockerRuntimeProvider } = await import("./docker-ff6y1190.js");
       return new DockerRuntimeProvider;
     }
     case "e2b": {
-      const { E2BRuntimeProvider } = await import("./e2b-66xra4az.js");
+      const { E2BRuntimeProvider } = await import("./e2b-8ygwhg0f.js");
       return new E2BRuntimeProvider(target);
     }
     case "k8s":

package/dist/cli-rhs9pz33.js

@@ -0,0 +1,294 @@
+import {
+  __commonJS
+} from "./cli-bc05qbss.js";
+
+// node_modules/retry/lib/retry_operation.js
+var require_retry_operation = __commonJS(function(exports, module) {
+  function RetryOperation(timeouts, options) {
+    if (typeof options === "boolean") {
+      options = { forever: options };
+    }
+    this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+    this._timeouts = timeouts;
+    this._options = options || {};
+    this._maxRetryTime = options && options.maxRetryTime || Infinity;
+    this._fn = null;
+    this._errors = [];
+    this._attempts = 1;
+    this._operationTimeout = null;
+    this._operationTimeoutCb = null;
+    this._timeout = null;
+    this._operationStart = null;
+    this._timer = null;
+    if (this._options.forever) {
+      this._cachedTimeouts = this._timeouts.slice(0);
+    }
+  }
+  module.exports = RetryOperation;
+  RetryOperation.prototype.reset = function() {
+    this._attempts = 1;
+    this._timeouts = this._originalTimeouts.slice(0);
+  };
+  RetryOperation.prototype.stop = function() {
+    if (this._timeout) {
+      clearTimeout(this._timeout);
+    }
+    if (this._timer) {
+      clearTimeout(this._timer);
+    }
+    this._timeouts = [];
+    this._cachedTimeouts = null;
+  };
+  RetryOperation.prototype.retry = function(err) {
+    if (this._timeout) {
+      clearTimeout(this._timeout);
+    }
+    if (!err) {
+      return false;
+    }
+    var currentTime = new Date().getTime();
+    if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+      this._errors.push(err);
+      this._errors.unshift(new Error("RetryOperation timeout occurred"));
+      return false;
+    }
+    this._errors.push(err);
+    var timeout = this._timeouts.shift();
+    if (timeout === undefined) {
+      if (this._cachedTimeouts) {
+        this._errors.splice(0, this._errors.length - 1);
+        timeout = this._cachedTimeouts.slice(-1);
+      } else {
+        return false;
+      }
+    }
+    var self = this;
+    this._timer = setTimeout(function() {
+      self._attempts++;
+      if (self._operationTimeoutCb) {
+        self._timeout = setTimeout(function() {
+          self._operationTimeoutCb(self._attempts);
+        }, self._operationTimeout);
+        if (self._options.unref) {
+          self._timeout.unref();
+        }
+      }
+      self._fn(self._attempts);
+    }, timeout);
+    if (this._options.unref) {
+      this._timer.unref();
+    }
+    return true;
+  };
+  RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+    this._fn = fn;
+    if (timeoutOps) {
+      if (timeoutOps.timeout) {
+        this._operationTimeout = timeoutOps.timeout;
+      }
+      if (timeoutOps.cb) {
+        this._operationTimeoutCb = timeoutOps.cb;
+      }
+    }
+    var self = this;
+    if (this._operationTimeoutCb) {
+      this._timeout = setTimeout(function() {
+        self._operationTimeoutCb();
+      }, self._operationTimeout);
+    }
+    this._operationStart = new Date().getTime();
+    this._fn(this._attempts);
+  };
+  RetryOperation.prototype.try = function(fn) {
+    console.log("Using RetryOperation.try() is deprecated");
+    this.attempt(fn);
+  };
+  RetryOperation.prototype.start = function(fn) {
+    console.log("Using RetryOperation.start() is deprecated");
+    this.attempt(fn);
+  };
+  RetryOperation.prototype.start = RetryOperation.prototype.try;
+  RetryOperation.prototype.errors = function() {
+    return this._errors;
+  };
+  RetryOperation.prototype.attempts = function() {
+    return this._attempts;
+  };
+  RetryOperation.prototype.mainError = function() {
+    if (this._errors.length === 0) {
+      return null;
+    }
+    var counts = {};
+    var mainError = null;
+    var mainErrorCount = 0;
+    for (var i = 0;i < this._errors.length; i++) {
+      var error = this._errors[i];
+      var message = error.message;
+      var count = (counts[message] || 0) + 1;
+      counts[message] = count;
+      if (count >= mainErrorCount) {
+        mainError = error;
+        mainErrorCount = count;
+      }
+    }
+    return mainError;
+  };
+});
+
+// node_modules/retry/lib/retry.js
+var require_retry = __commonJS(function(exports) {
+  var RetryOperation = require_retry_operation();
+  exports.operation = function(options) {
+    var timeouts = exports.timeouts(options);
+    return new RetryOperation(timeouts, {
+      forever: options && (options.forever || options.retries === Infinity),
+      unref: options && options.unref,
+      maxRetryTime: options && options.maxRetryTime
+    });
+  };
+  exports.timeouts = function(options) {
+    if (options instanceof Array) {
+      return [].concat(options);
+    }
+    var opts = {
+      retries: 10,
+      factor: 2,
+      minTimeout: 1 * 1000,
+      maxTimeout: Infinity,
+      randomize: false
+    };
+    for (var key in options) {
+      opts[key] = options[key];
+    }
+    if (opts.minTimeout > opts.maxTimeout) {
+      throw new Error("minTimeout is greater than maxTimeout");
+    }
+    var timeouts = [];
+    for (var i = 0;i < opts.retries; i++) {
+      timeouts.push(this.createTimeout(i, opts));
+    }
+    if (options && options.forever && !timeouts.length) {
+      timeouts.push(this.createTimeout(i, opts));
+    }
+    timeouts.sort(function(a, b) {
+      return a - b;
+    });
+    return timeouts;
+  };
+  exports.createTimeout = function(attempt, opts) {
+    var random = opts.randomize ? Math.random() + 1 : 1;
+    var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+    timeout = Math.min(timeout, opts.maxTimeout);
+    return timeout;
+  };
+  exports.wrap = function(obj, options, methods) {
+    if (options instanceof Array) {
+      methods = options;
+      options = null;
+    }
+    if (!methods) {
+      methods = [];
+      for (var key in obj) {
+        if (typeof obj[key] === "function") {
+          methods.push(key);
+        }
+      }
+    }
+    for (var i = 0;i < methods.length; i++) {
+      var method = methods[i];
+      var original = obj[method];
+      obj[method] = function retryWrapper(original2) {
+        var op = exports.operation(options);
+        var args = Array.prototype.slice.call(arguments, 1);
+        var callback = args.pop();
+        args.push(function(err) {
+          if (op.retry(err)) {
+            return;
+          }
+          if (err) {
+            arguments[0] = op.mainError();
+          }
+          callback.apply(this, arguments);
+        });
+        op.attempt(function() {
+          original2.apply(obj, args);
+        });
+      }.bind(obj, original);
+      obj[method].options = options;
+    }
+  };
+});
+
+// node_modules/p-retry/index.js
+var require_p_retry = __commonJS(function(exports, module) {
+  var retry = require_retry();
+  var networkErrorMsgs = [
+    "Failed to fetch",
+    "NetworkError when attempting to fetch resource.",
+    "The Internet connection appears to be offline.",
+    "Network request failed"
+  ];
+
+  class AbortError extends Error {
+    constructor(message) {
+      super();
+      if (message instanceof Error) {
+        this.originalError = message;
+        ({ message } = message);
+      } else {
+        this.originalError = new Error(message);
+        this.originalError.stack = this.stack;
+      }
+      this.name = "AbortError";
+      this.message = message;
+    }
+  }
+  var decorateErrorWithCounts = (error, attemptNumber, options) => {
+    const retriesLeft = options.retries - (attemptNumber - 1);
+    error.attemptNumber = attemptNumber;
+    error.retriesLeft = retriesLeft;
+    return error;
+  };
+  var isNetworkError = (errorMessage) => networkErrorMsgs.includes(errorMessage);
+  var pRetry = (input, options) => new Promise((resolve, reject) => {
+    options = {
+      onFailedAttempt: () => {},
+      retries: 10,
+      ...options
+    };
+    const operation = retry.operation(options);
+    operation.attempt(async (attemptNumber) => {
+      try {
+        resolve(await input(attemptNumber));
+      } catch (error) {
+        if (!(error instanceof Error)) {
+          reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
+          return;
+        }
+        if (error instanceof AbortError) {
+          operation.stop();
+          reject(error.originalError);
+        } else if (error instanceof TypeError && !isNetworkError(error.message)) {
+          operation.stop();
+          reject(error);
+        } else {
+          decorateErrorWithCounts(error, attemptNumber, options);
+          try {
+            await options.onFailedAttempt(error);
+          } catch (error2) {
+            reject(error2);
+            return;
+          }
+          if (!operation.retry(error)) {
+            reject(operation.mainError());
+          }
+        }
+      }
+    });
+  });
+  module.exports = pRetry;
+  module.exports.default = pRetry;
+  module.exports.AbortError = AbortError;
+});
+
+export { require_p_retry };