@desplega.ai/agent-swarm 2.4.5 → 2.5.1

package/dist/{cli-1dmcq2eh.js → cli-nzfnt2gs.js}

@@ -2,7 +2,7 @@ import {
   DEFAULT_E2B_API_BASE,
   redactWithEnv,
   init_env
-} from "./cli-pemywhfq.js";
+} from "./cli-ha9rmwgq.js";
 import {
   __toESM,
   __esm

package/dist/{cli-625tb7aq.js → cli-p859hcc8.js}

@@ -13,11 +13,11 @@ async function createRuntimeProvider(kind, target = {}) {
       return new StaticRuntimeProvider;
     }
     case "docker": {
-      const { DockerRuntimeProvider } = await import("./docker-fkgtr75t.js");
+      const { DockerRuntimeProvider } = await import("./docker-nfy2gc8t.js");
       return new DockerRuntimeProvider;
     }
     case "e2b": {
-      const { E2BRuntimeProvider } = await import("./e2b-zn0b4w5w.js");
+      const { E2BRuntimeProvider } = await import("./e2b-cjtf8k1z.js");
       return new E2BRuntimeProvider(target);
     }
     case "k8s":

package/dist/{cli-smvcw9z5.js → cli-pasyvjmm.js}

@@ -3,7 +3,7 @@ import {
   scrubObject,
   registerVolatileSecret,
   init_secret_scrubber
-} from "./cli-xf234ws8.js";
+} from "./cli-n4c8e3s5.js";
 
 // src/x/composio.ts
 init_secret_scrubber();

package/dist/cli-pkaqk57w.js

@@ -0,0 +1,128 @@
+// node_modules/@earendil-works/pi-ai/dist/utils/version.js
+var PI_AI_VERSION = "1.4.0";
+
+// node_modules/@earendil-works/pi-ai/dist/utils/identity.js
+var PI_ATTRIBUTION = { name: "pi", url: "https://pi.dev", categories: ["cli-agent"] };
+var NVIDIA_NIM_HOST = "integrate.api.nvidia.com";
+var OPENCODE_HOST = "opencode.ai";
+function mergeClientIdentity(...sources) {
+  let merged;
+  for (const source of sources) {
+    if (!source)
+      continue;
+    merged = { ...merged };
+    if (source.userAgent !== undefined)
+      merged.userAgent = source.userAgent;
+    if (source.attribution !== undefined)
+      merged.attribution = source.attribution;
+    if (source.version !== undefined)
+      merged.version = source.version;
+  }
+  return merged;
+}
+function getClientVersion(identity) {
+  return identity?.version ?? PI_AI_VERSION;
+}
+function runtimeDescription() {
+  if (typeof process === "undefined")
+    return;
+  const versions = process.versions;
+  if (versions?.bun)
+    return `bun/${versions.bun}`;
+  if (versions?.node)
+    return `node/${process.version}`;
+  return;
+}
+function formatUserAgent(identity) {
+  const mode = identity?.userAgent ?? "detailed";
+  if (typeof mode === "object")
+    return mode.custom;
+  if (mode === "short")
+    return "pi";
+  const product = `pi/${getClientVersion(identity)}`;
+  const runtime = runtimeDescription();
+  return runtime ? `${product} (${process.platform}; ${runtime}; ${process.arch})` : `${product} (browser)`;
+}
+function matchesHost(baseUrl, expectedHost) {
+  try {
+    return new URL(baseUrl).hostname === expectedHost;
+  } catch {
+    return false;
+  }
+}
+function isOpenRouter(target) {
+  return target.provider === "openrouter" || target.baseUrl.includes("openrouter.ai");
+}
+function isNvidiaNim(target) {
+  return target.provider === "nvidia" || matchesHost(target.baseUrl, NVIDIA_NIM_HOST);
+}
+function isOpenCode(target) {
+  return target.provider === "opencode" || target.provider === "opencode-go" || matchesHost(target.baseUrl, OPENCODE_HOST);
+}
+function getAttributionHeaders(target, identity) {
+  const attribution = identity?.attribution;
+  if (!attribution)
+    return {};
+  const { name, url, categories } = attribution;
+  if (isOpenRouter(target)) {
+    return {
+      "HTTP-Referer": url,
+      "X-OpenRouter-Title": name,
+      ...categories === undefined || categories.length === 0 ? {} : { "X-OpenRouter-Categories": categories.join(",") }
+    };
+  }
+  if (isNvidiaNim(target))
+    return { "X-BILLING-INVOKE-ORIGIN": name.charAt(0).toUpperCase() + name.slice(1) };
+  if (isOpenCode(target))
+    return { "x-opencode-client": name };
+  return {};
+}
+function getOpenCodeSessionHeaders(target, sessionId) {
+  return sessionId && isOpenCode(target) ? { "x-opencode-session": sessionId } : undefined;
+}
+function getIdentityHeaders(target, identity) {
+  return { "User-Agent": formatUserAgent(identity), ...getAttributionHeaders(target, identity) };
+}
+function isMutableModels(models) {
+  return "setProvider" in models && "deleteProvider" in models && "clearProviders" in models;
+}
+function withClientIdentity(models, identity) {
+  const withIdentity = (options) => ({ ...options, identity: mergeClientIdentity(identity, options?.identity) });
+  const wrapped = {
+    getProviders: () => models.getProviders(),
+    getProvider: (id) => models.getProvider(id),
+    getModels: (provider) => models.getModels(provider),
+    getModel: (provider, id) => models.getModel(provider, id),
+    getModelsOfType: (type, provider) => models.getModelsOfType(type, provider),
+    getModelOfType: (type, provider, id) => models.getModelOfType(type, provider, id),
+    getAllModels: (provider) => models.getAllModels(provider),
+    refresh: (options) => models.refresh(options),
+    checkAuth: (providerId, options) => models.checkAuth(providerId, options),
+    getAvailable: (providerId, options) => models.getAvailable(providerId, options),
+    getAvailableOfType: (type, providerId, options) => models.getAvailableOfType(type, providerId, options),
+    getAllAvailable: (providerId, options) => models.getAllAvailable(providerId, options),
+    getAuth: models.getAuth.bind(models),
+    login: (providerId, type, interaction, options) => models.login(providerId, type, interaction, options),
+    logout: (providerId, options) => models.logout(providerId, options),
+    stream: (model, context, options) => models.stream(model, context, withIdentity(options)),
+    complete: (model, context, options) => models.complete(model, context, withIdentity(options)),
+    streamSimple: (model, context, options) => models.streamSimple(model, context, withIdentity(options)),
+    completeSimple: (model, context, options) => models.completeSimple(model, context, withIdentity(options)),
+    streamDeferred: (model, handle, options) => models.streamDeferred(model, handle, withIdentity(options)),
+    fetchDeferred: (model, handle, options) => models.fetchDeferred(model, handle, withIdentity(options)),
+    cancelDeferred: (model, handle, options) => models.cancelDeferred(model, handle, withIdentity(options)),
+    generateImages: (model, context, options) => models.generateImages(model, context, withIdentity(options)),
+    classify: (model, context, options) => models.classify(model, context, withIdentity(options))
+  };
+  if (!isMutableModels(models))
+    return wrapped;
+  const mutable = {
+    ...wrapped,
+    setProvider: (provider) => models.setProvider(provider),
+    deleteProvider: (id) => models.deleteProvider(id),
+    clearProviders: () => models.clearProviders()
+  };
+  return mutable;
+}
+
+export { PI_AI_VERSION, PI_ATTRIBUTION, mergeClientIdentity, getClientVersion, formatUserAgent, getAttributionHeaders, getOpenCodeSessionHeaders, getIdentityHeaders, withClientIdentity };