@desplega.ai/agent-swarm 2.5.4 → 2.6.0

package/dist/cli-e45e4m6b.js

@@ -1,413 +0,0 @@
-import {
-  __esm
-} from "./cli-242037k3.js";
-
-// packages/model-routing/src/env.ts
-function envValue(env, key) {
-  const value = env[key]?.trim();
-  return value ? value : undefined;
-}
-function isEnvTruthy(env, key) {
-  const value = envValue(env, key)?.toLowerCase();
-  return value === "1" || value === "true" || value === "yes" || value === "on";
-}
-var init_env = () => {};
-
-// packages/model-routing/src/protocols.ts
-function defineRouteProvider(p) {
-  return {
-    ...p,
-    isHarnessDefaultProtocol: p.isHarnessDefaultProtocol ?? ((harness, protocol) => HARNESS_DEFAULT_PROTOCOL[harness] === protocol)
-  };
-}
-var HARNESS_DEFAULT_PROTOCOL;
-var init_protocols = __esm(() => {
-  HARNESS_DEFAULT_PROTOCOL = {
-    claude: "anthropic-messages",
-    codex: "openai-responses",
-    pi: "openai-chat",
-    opencode: "openai-chat",
-    dsh: "openai-chat"
-  };
-});
-
-// packages/model-routing/src/providers/anthropic-models.ts
-function routeAuthHeaders(ctx) {
-  const { auth } = ctx.route;
-  if (auth.kind !== "bearer" && auth.kind !== "x-api-key" && auth.kind !== "header")
-    return {};
-  const secret = envValue(ctx.env, auth.secretKey);
-  if (!secret)
-    return {};
-  if (auth.kind === "bearer")
-    return { Authorization: `Bearer ${secret}` };
-  if (auth.kind === "x-api-key")
-    return { "x-api-key": secret };
-  return { [auth.header]: secret };
-}
-async function readBody(res) {
-  try {
-    return await res.text();
-  } catch {
-    return "";
-  }
-}
-function modelIds(body) {
-  try {
-    const parsed = JSON.parse(body);
-    if (!Array.isArray(parsed.data))
-      return;
-    return parsed.data.flatMap((m) => typeof m.id === "string" ? [m.id] : []);
-  } catch {
-    return;
-  }
-}
-async function checkAnthropicModels(ctx, opts = {}) {
-  const res = await ctx.fetch("/v1/models", {
-    method: "GET",
-    headers: {
-      "anthropic-version": ANTHROPIC_VERSION,
-      ...opts.extraHeaders,
-      ...routeAuthHeaders(ctx)
-    },
-    signal: ctx.signal
-  });
-  const body = await readBody(res);
-  if (res.ok)
-    return { status: "verified", models: modelIds(body) };
-  if (opts.notFoundIsConfigured && (res.status === 404 || res.status === 405)) {
-    return {
-      status: "configured",
-      reason: `HTTP ${res.status}: the endpoint does not list models, so the key was not checked`
-    };
-  }
-  return { status: "failed", reason: `HTTP ${res.status}: ${body.slice(0, 200)}` };
-}
-var ANTHROPIC_VERSION = "2023-06-01";
-var init_anthropic_models = __esm(() => {
-  init_env();
-});
-
-// packages/model-routing/src/providers/secret-env.ts
-function secretEnv(route) {
-  const { auth } = route;
-  return "secretKey" in auth ? [auth.secretKey] : [];
-}
-var init_secret_env = () => {};
-
-// packages/model-routing/src/providers/anthropic.ts
-var ANTHROPIC_API_BASE_URL = "https://api.anthropic.com", anthropicProvider;
-var init_anthropic = __esm(() => {
-  init_protocols();
-  init_anthropic_models();
-  init_secret_env();
-  anthropicProvider = defineRouteProvider({
-    id: "anthropic",
-    name: "Anthropic API",
-    protocols: ["anthropic-messages"],
-    defaultBaseUrl: ANTHROPIC_API_BASE_URL,
-    requiredEnv: (route) => secretEnv(route),
-    validate: (ctx) => checkAnthropicModels(ctx)
-  });
-});
-
-// packages/model-routing/src/providers/anthropic-gateway.ts
-function customHeaders(route, env) {
-  if (route.source !== "default")
-    return {};
-  const raw = envValue(env, "ANTHROPIC_CUSTOM_HEADERS");
-  if (!raw)
-    return {};
-  const headers = {};
-  for (const line of raw.split(`
-`)) {
-    const colon = line.indexOf(":");
-    if (colon <= 0)
-      continue;
-    const name = line.slice(0, colon).trim();
-    const value = line.slice(colon + 1).trim();
-    if (name && value)
-      headers[name] = value;
-  }
-  return headers;
-}
-var anthropicGatewayProvider;
-var init_anthropic_gateway = __esm(() => {
-  init_env();
-  init_protocols();
-  init_anthropic_models();
-  init_secret_env();
-  anthropicGatewayProvider = defineRouteProvider({
-    id: "anthropic-gateway",
-    name: "Anthropic-compatible gateway",
-    protocols: ["anthropic-messages"],
-    requiredEnv: (route) => secretEnv(route),
-    validate: (ctx) => checkAnthropicModels(ctx, {
-      extraHeaders: customHeaders(ctx.route, ctx.env),
-      notFoundIsConfigured: true
-    })
-  });
-});
-
-// packages/model-routing/src/providers/bedrock.ts
-var bedrockProvider;
-var init_bedrock = __esm(() => {
-  init_protocols();
-  init_secret_env();
-  bedrockProvider = defineRouteProvider({
-    id: "bedrock",
-    name: "Amazon Bedrock",
-    protocols: ["bedrock"],
-    requiredEnv: (route) => ["AWS_REGION", ...secretEnv(route)]
-  });
-});
-
-// packages/model-routing/src/providers/claude-subscription.ts
-var claudeSubscriptionProvider;
-var init_claude_subscription = __esm(() => {
-  init_protocols();
-  init_anthropic();
-  claudeSubscriptionProvider = defineRouteProvider({
-    id: "claude-subscription",
-    name: "Claude subscription",
-    protocols: ["anthropic-messages"],
-    harnesses: ["claude"],
-    defaultBaseUrl: ANTHROPIC_API_BASE_URL,
-    requiredEnv: () => ["CLAUDE_CODE_OAUTH_TOKEN"],
-    validate: async () => ({ status: "verified" })
-  });
-});
-
-// packages/model-routing/src/providers/foundry.ts
-function foundryBaseUrl(resource) {
-  return `https://${resource}.services.ai.azure.com/anthropic`;
-}
-var foundryProvider;
-var init_foundry = __esm(() => {
-  init_protocols();
-  init_secret_env();
-  foundryProvider = defineRouteProvider({
-    id: "foundry",
-    name: "Microsoft Foundry",
-    protocols: ["foundry"],
-    requiredEnv: (route) => [
-      ...route.baseUrl ? [] : ["ANTHROPIC_FOUNDRY_RESOURCE"],
-      ...secretEnv(route)
-    ]
-  });
-});
-
-// packages/model-routing/src/providers/vertex.ts
-var vertexProvider;
-var init_vertex = __esm(() => {
-  init_protocols();
-  vertexProvider = defineRouteProvider({
-    id: "vertex",
-    name: "Google Vertex AI",
-    protocols: ["vertex"],
-    requiredEnv: () => ["CLOUD_ML_REGION", "ANTHROPIC_VERTEX_PROJECT_ID"]
-  });
-});
-
-// packages/model-routing/src/providers/index.ts
-function getRouteProvider(id) {
-  return ROUTE_PROVIDERS.find((p) => p.id === id);
-}
-var ROUTE_PROVIDERS;
-var init_providers = __esm(() => {
-  init_anthropic();
-  init_anthropic_gateway();
-  init_bedrock();
-  init_claude_subscription();
-  init_foundry();
-  init_vertex();
-  ROUTE_PROVIDERS = [
-    anthropicProvider,
-    claudeSubscriptionProvider,
-    anthropicGatewayProvider,
-    foundryProvider,
-    bedrockProvider,
-    vertexProvider
-  ];
-});
-
-// packages/model-routing/src/scoped-fetch.ts
-function isAbsolute(path) {
-  return /^[a-z][a-z0-9+.-]*:/i.test(path) || path.startsWith("//");
-}
-function createScopedFetch(baseUrl, impl) {
-  let base;
-  try {
-    base = new URL(baseUrl);
-  } catch {
-    throw new ScopedFetchError(`Invalid route base URL: ${baseUrl}`);
-  }
-  const prefix = base.href.replace(/\/+$/, "");
-  return (path, init) => {
-    let target;
-    try {
-      target = isAbsolute(path) ? new URL(path, base) : new URL(`${prefix}/${path.replace(/^\/+/, "")}`);
-    } catch {
-      return Promise.reject(new ScopedFetchError(`Invalid route path: ${path}`));
-    }
-    if (target.origin !== base.origin) {
-      return Promise.reject(new ScopedFetchError(`Refusing request to ${target.origin}: route is scoped to ${base.origin}`));
-    }
-    const doFetch = impl ?? globalThis.fetch;
-    return doFetch(target.href, { ...init, redirect: "manual" });
-  };
-}
-var ScopedFetchError;
-var init_scoped_fetch = __esm(() => {
-  ScopedFetchError = class ScopedFetchError extends Error {
-    name = "ScopedFetchError";
-  };
-});
-
-// packages/model-routing/src/credential-status.ts
-function describeRoute(route, providerName) {
-  return route.baseUrl ? `${providerName} at ${route.baseUrl}` : providerName;
-}
-function routeCredentialStatus(route, env) {
-  const provider = getRouteProvider(route.provider);
-  if (!provider) {
-    return { ready: false, missing: [], hint: `Unknown route provider "${route.provider}".` };
-  }
-  const missing = provider.requiredEnv(route).filter((key) => !envValue(env, key));
-  const where = describeRoute(route, provider.name);
-  return missing.length === 0 ? { ready: true, missing: [], hint: `Routing through ${where}.` } : { ready: false, missing, hint: `${where} needs ${missing.join(", ")}.` };
-}
-async function validateRoute(route, env, opts = {}) {
-  const provider = getRouteProvider(route.provider);
-  const status = routeCredentialStatus(route, env);
-  if (!provider || !status.ready) {
-    return { status: "failed", reason: status.hint, missing: status.missing };
-  }
-  if (!provider.validate) {
-    return {
-      status: "configured",
-      reason: `${provider.name} has no free credential check; the first task proves the route.`
-    };
-  }
-  const baseUrl = route.baseUrl ?? provider.defaultBaseUrl;
-  const controller = new AbortController;
-  const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? VALIDATE_TIMEOUT_MS);
-  try {
-    const scopedFetch = baseUrl ? createScopedFetch(baseUrl) : () => Promise.reject(new ScopedFetchError(`Route "${route.name}" has no base URL.`));
-    return await provider.validate({ route, env, fetch: scopedFetch, signal: controller.signal });
-  } catch (err) {
-    return { status: "failed", reason: err instanceof Error ? err.message : String(err) };
-  } finally {
-    clearTimeout(timer);
-  }
-}
-var VALIDATE_TIMEOUT_MS = 5000;
-var init_credential_status = __esm(() => {
-  init_env();
-  init_protocols();
-  init_providers();
-  init_scoped_fetch();
-});
-
-// packages/model-routing/src/default-route.ts
-function isFirstPartyAnthropicUrl(url) {
-  try {
-    return new URL(url).origin === ANTHROPIC_API_BASE_URL;
-  } catch {
-    return false;
-  }
-}
-function defaultRoute(harness, route) {
-  return { id: `default:${harness}`, name: `default:${harness}`, source: "default", ...route };
-}
-function deriveClaudeDefaultRoute(env) {
-  if (isEnvTruthy(env, "CLAUDE_CODE_USE_FOUNDRY")) {
-    const resource = envValue(env, "ANTHROPIC_FOUNDRY_RESOURCE");
-    const auth = envValue(env, "ANTHROPIC_FOUNDRY_AUTH_TOKEN") ? { kind: "bearer", secretKey: "ANTHROPIC_FOUNDRY_AUTH_TOKEN" } : envValue(env, "ANTHROPIC_FOUNDRY_API_KEY") ? { kind: "x-api-key", secretKey: "ANTHROPIC_FOUNDRY_API_KEY" } : { kind: "cloud-chain" };
-    return defaultRoute("claude", {
-      provider: "foundry",
-      protocol: "foundry",
-      baseUrl: envValue(env, "ANTHROPIC_FOUNDRY_BASE_URL") ?? (resource ? foundryBaseUrl(resource) : undefined),
-      auth,
-      cloud: { resource }
-    });
-  }
-  if (isEnvTruthy(env, "CLAUDE_CODE_USE_BEDROCK")) {
-    const region = envValue(env, "AWS_REGION");
-    return defaultRoute("claude", {
-      provider: "bedrock",
-      protocol: "bedrock",
-      baseUrl: envValue(env, "ANTHROPIC_BEDROCK_BASE_URL") ?? (region ? `https://bedrock-runtime.${region}.amazonaws.com` : undefined),
-      auth: envValue(env, "AWS_BEARER_TOKEN_BEDROCK") ? { kind: "bearer", secretKey: "AWS_BEARER_TOKEN_BEDROCK" } : { kind: "cloud-chain" },
-      cloud: { region }
-    });
-  }
-  if (isEnvTruthy(env, "CLAUDE_CODE_USE_VERTEX")) {
-    const region = envValue(env, "CLOUD_ML_REGION");
-    const vertexHost = region === "global" ? "aiplatform.googleapis.com" : `${region}-aiplatform.googleapis.com`;
-    return defaultRoute("claude", {
-      provider: "vertex",
-      protocol: "vertex",
-      baseUrl: envValue(env, "ANTHROPIC_VERTEX_BASE_URL") ?? (region ? `https://${vertexHost}` : undefined),
-      auth: { kind: "cloud-chain" },
-      cloud: { region, project: envValue(env, "ANTHROPIC_VERTEX_PROJECT_ID") }
-    });
-  }
-  const oauthToken = envValue(env, "CLAUDE_CODE_OAUTH_TOKEN");
-  const baseUrl = envValue(env, "ANTHROPIC_BASE_URL");
-  if (baseUrl && !isFirstPartyAnthropicUrl(baseUrl)) {
-    const authToken = envValue(env, "ANTHROPIC_AUTH_TOKEN");
-    const apiKey = envValue(env, "ANTHROPIC_API_KEY");
-    return defaultRoute("claude", {
-      provider: "anthropic-gateway",
-      protocol: "anthropic-messages",
-      baseUrl,
-      auth: authToken || !apiKey ? { kind: "bearer", secretKey: "ANTHROPIC_AUTH_TOKEN" } : { kind: "x-api-key", secretKey: "ANTHROPIC_API_KEY" }
-    });
-  }
-  if (oauthToken) {
-    return defaultRoute("claude", {
-      provider: "claude-subscription",
-      protocol: "anthropic-messages",
-      baseUrl: baseUrl ?? ANTHROPIC_API_BASE_URL,
-      auth: { kind: "subscription", plan: "claude" }
-    });
-  }
-  if (envValue(env, "ANTHROPIC_API_KEY")) {
-    return defaultRoute("claude", {
-      provider: "anthropic",
-      protocol: "anthropic-messages",
-      baseUrl: baseUrl ?? ANTHROPIC_API_BASE_URL,
-      auth: { kind: "x-api-key", secretKey: "ANTHROPIC_API_KEY" }
-    });
-  }
-  return null;
-}
-function deriveDefaultRoute(harness, env) {
-  if (harness === "claude")
-    return deriveClaudeDefaultRoute(env);
-  return null;
-}
-function routeUnsetEnv(harness, route) {
-  if (harness === "claude" && route.provider !== "claude-subscription") {
-    return ["CLAUDE_CODE_OAUTH_TOKEN"];
-  }
-  return [];
-}
-var init_default_route = __esm(() => {
-  init_env();
-  init_anthropic();
-  init_foundry();
-});
-
-// packages/model-routing/src/index.ts
-var init_src = __esm(() => {
-  init_credential_status();
-  init_default_route();
-  init_protocols();
-  init_anthropic();
-  init_providers();
-  init_scoped_fetch();
-});
-
-export { routeCredentialStatus, validateRoute, isFirstPartyAnthropicUrl, deriveDefaultRoute, routeUnsetEnv, init_src };