@desplega.ai/agent-swarm 2.5.3 → 2.6.0

package/dist/{cli-hcpj2xqz.js → cli-n7asmce6.js}

@@ -1,10 +1,34 @@
+import {
+  publicEndpointSsrfOptions
+} from "./cli-3gfvmzht.js";
 import {
   getMemoryRaterNames
 } from "./cli-3h26v7yj.js";
 import {
   normalizeOrgWebsite,
-  init_org_website
-} from "./cli-kxawjrxg.js";
+  init_org_website,
+  assertUrlSafe
+} from "./cli-g8ka5j4j.js";
+import {
+  getRouteProvider,
+  createScopedFetch,
+  deriveDefaultRoute,
+  init_src
+} from "./cli-1tem6ns9.js";
+import {
+  getOpenRouterBaseUrl,
+  getOpenRouterAttributionHeaders,
+  init_openrouter_base_url
+} from "./cli-dfyv0jdy.js";
+import {
+  scrubSecrets,
+  init_secret_scrubber
+} from "./cli-708wdy32.js";
+import {
+  providerBaseUrl,
+  providerForKeyVar,
+  init_src2
+} from "./cli-gxee0bqa.js";
 
 // src/utils/lead-monitor-channels.ts
 function isLeadChannelMonitoringEnabled(env = process.env) {
@@ -117,6 +141,204 @@ function isUnknownModelError(text, modelId) {
   });
 }
 
+// src/utils/provider-key-probes.ts
+init_src2();
+init_src();
+init_openrouter_base_url();
+init_secret_scrubber();
+var LIVE_TEST_TIMEOUT_MS = 5000;
+function scrubProbeBody(body, init) {
+  const headers = new Headers(init.headers);
+  const apiKey = headers.get("x-api-key") ?? headers.get("authorization")?.replace(/^Bearer\s+/i, "");
+  return scrubSecrets(apiKey ? body.replaceAll(apiKey, "[REDACTED]") : body);
+}
+async function timedFetch(url, init, options = {}) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), LIVE_TEST_TIMEOUT_MS);
+  const start = Date.now();
+  try {
+    if (options.publicEndpoint)
+      assertUrlSafe(url, publicEndpointSsrfOptions());
+    const res = await fetch(url, {
+      ...init,
+      ...options.publicEndpoint ? { redirect: "manual" } : {},
+      signal: controller.signal
+    });
+    let bodyText = "";
+    try {
+      bodyText = scrubProbeBody(await res.text(), init);
+    } catch {}
+    return {
+      ok: res.ok,
+      status: res.status,
+      bodyText,
+      latency_ms: Date.now() - start
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function checkAnthropicApiKey(apiKey, options = {}) {
+  const r = await timedFetch("https://api.anthropic.com/v1/models", {
+    method: "GET",
+    headers: { "x-api-key": apiKey, "anthropic-version": "2023-06-01" }
+  }, options);
+  if (r.ok)
+    return { ok: true, latency_ms: r.latency_ms };
+  return {
+    ok: false,
+    error: scrubSecrets(`HTTP ${r.status}: ${r.bodyText.slice(0, 200)}`),
+    httpStatus: r.status,
+    latency_ms: r.latency_ms
+  };
+}
+async function checkOpenAiApiKey(apiKey, options = {}) {
+  const r = await timedFetch("https://api.openai.com/v1/models", {
+    method: "GET",
+    headers: { Authorization: `Bearer ${apiKey}` }
+  }, options);
+  if (r.ok)
+    return { ok: true, latency_ms: r.latency_ms };
+  return {
+    ok: false,
+    error: scrubSecrets(`HTTP ${r.status}: ${r.bodyText.slice(0, 200)}`),
+    httpStatus: r.status,
+    latency_ms: r.latency_ms
+  };
+}
+async function checkXaiApiKey(apiKey, options = {}) {
+  const r = await timedFetch("https://api.x.ai/v1/models", {
+    method: "GET",
+    headers: { Authorization: `Bearer ${apiKey}` }
+  }, options);
+  if (r.ok)
+    return { ok: true, latency_ms: r.latency_ms };
+  return {
+    ok: false,
+    error: scrubSecrets(`HTTP ${r.status}: ${r.bodyText.slice(0, 200)}`),
+    httpStatus: r.status,
+    latency_ms: r.latency_ms
+  };
+}
+async function checkBearerGet(url, init, options = {}) {
+  const r = await timedFetch(url, { method: "GET", ...init }, options);
+  if (r.ok)
+    return { ok: true, latency_ms: r.latency_ms };
+  return {
+    ok: false,
+    error: scrubSecrets(`HTTP ${r.status}: ${r.bodyText.slice(0, 200)}`),
+    httpStatus: r.status,
+    latency_ms: r.latency_ms
+  };
+}
+async function checkOpenRouter(apiKey, options = {}) {
+  const base = getOpenRouterBaseUrl(options.env);
+  const get = (url) => checkBearerGet(url, {
+    headers: {
+      ...getOpenRouterAttributionHeaders(url, options.env),
+      Authorization: `Bearer ${apiKey}`
+    }
+  }, options);
+  const keyResult = await get(`${base}/key`);
+  if (keyResult.httpStatus === 404 || keyResult.httpStatus === 405)
+    return get(`${base}/models`);
+  return keyResult;
+}
+function checkDeepSeekApiKey(apiKey, options = {}) {
+  return checkBearerGet("https://api.deepseek.com/models", {
+    headers: { Authorization: `Bearer ${apiKey}` }
+  }, options);
+}
+async function checkOpenAICompatibleProvider(provider, apiKey, baseUrl = provider.baseUrl, options = {}) {
+  const r = await timedFetch(`${baseUrl.replace(/\/+$/, "")}/models`, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${apiKey}` }
+  }, options);
+  if (r.ok)
+    return { ok: true, latency_ms: r.latency_ms };
+  return {
+    ok: false,
+    error: scrubSecrets(`HTTP ${r.status}: ${r.bodyText.slice(0, 200)}`),
+    httpStatus: r.status,
+    latency_ms: r.latency_ms
+  };
+}
+async function checkRoute(route, env) {
+  const startedAt = Date.now();
+  const provider = getRouteProvider(route.provider);
+  const baseUrl = route.baseUrl ?? provider?.defaultBaseUrl;
+  if (!provider?.validate || !baseUrl)
+    return { ok: true, skipped: true, latency_ms: 0 };
+  const publicFetch = async (url, init) => {
+    assertUrlSafe(String(url), publicEndpointSsrfOptions());
+    const res = await fetch(url, init);
+    if (res.ok || !res.body)
+      return res;
+    return new Response(scrubProbeBody(await res.text(), init ?? {}), {
+      status: res.status,
+      statusText: res.statusText,
+      headers: res.headers
+    });
+  };
+  const result = await provider.validate({
+    route,
+    env,
+    signal: AbortSignal.timeout(LIVE_TEST_TIMEOUT_MS),
+    fetch: createScopedFetch(baseUrl, publicFetch)
+  });
+  const latency_ms = Date.now() - startedAt;
+  if (result.status === "verified")
+    return { ok: true, latency_ms };
+  return {
+    ok: result.status === "configured",
+    ...result.status === "configured" ? { skipped: true } : { httpStatus: result.httpStatus },
+    error: scrubSecrets(result.reason),
+    latency_ms
+  };
+}
+async function checkProviderPoolKey(keyType, apiKey, env = process.env) {
+  const startedAt = Date.now();
+  const options = { env, publicEndpoint: true };
+  try {
+    switch (keyType) {
+      case "ANTHROPIC_API_KEY": {
+        const keyEnv = { ...env, ANTHROPIC_API_KEY: apiKey };
+        const route = deriveDefaultRoute("claude", keyEnv);
+        if (route?.provider === "anthropic-gateway" && "secretKey" in route.auth && route.auth.secretKey === "ANTHROPIC_API_KEY") {
+          return await checkRoute(route, keyEnv);
+        }
+        return await checkAnthropicApiKey(apiKey, options);
+      }
+      case "OPENAI_API_KEY":
+        return await checkOpenAiApiKey(apiKey, options);
+      case "OPENROUTER_API_KEY":
+        return await checkOpenRouter(apiKey, options);
+      case "DEEPSEEK_API_KEY":
+        return await checkDeepSeekApiKey(apiKey, options);
+      case "XAI_API_KEY":
+        return await checkXaiApiKey(apiKey, options);
+      case "CLAUDE_CODE_OAUTH_TOKEN": {
+        const tokenEnv = { CLAUDE_CODE_OAUTH_TOKEN: apiKey };
+        return await checkRoute(deriveDefaultRoute("claude", tokenEnv), tokenEnv);
+      }
+      default: {
+        const provider = providerForKeyVar(keyType);
+        if (provider) {
+          return await checkOpenAICompatibleProvider(provider, apiKey, providerBaseUrl(provider, env), options);
+        }
+        return { ok: true, skipped: true, latency_ms: 0 };
+      }
+    }
+  } catch (err) {
+    const raw = err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      error: scrubSecrets(raw.split(apiKey).join("[REDACTED]")) || "Unknown error",
+      latency_ms: Date.now() - startedAt
+    };
+  }
+}
+
 // src/utils/skill-fs-writer.ts
 import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -256,4 +478,4 @@ function writeSkillsToFilesystem(entries, harnessType = "all", home) {
   return { synced, removed, errors };
 }
 
-export { isLeadChannelMonitoringEnabled, ORG_IDENTITY_KEYS, orgIdentityStatus, SIMILARITY_THRESHOLD, memoryRelevance, renderMemoriesPrompt, isUnknownModelError, writeSkillsToFilesystem };
+export { isLeadChannelMonitoringEnabled, ORG_IDENTITY_KEYS, orgIdentityStatus, SIMILARITY_THRESHOLD, memoryRelevance, renderMemoriesPrompt, isUnknownModelError, timedFetch, checkAnthropicApiKey, checkOpenAiApiKey, checkXaiApiKey, checkOpenRouter, checkDeepSeekApiKey, checkOpenAICompatibleProvider, checkProviderPoolKey, writeSkillsToFilesystem };

package/dist/{cli-y561h5a9.js → cli-nn6vx2mq.js}

@@ -7,7 +7,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@desplega.ai/agent-swarm",
-    version: "2.5.3",
+    version: "2.6.0",
     description: "agent-swarm.dev — an open-source operating system for AI work: a lead agent breaks goals into tasks, routes them to specialized workers such as Claude Code or Codex, runs each worker in an isolated container, and preserves shared memory, tools, schedules, and review gates so delegated work compounds across sessions.",
     keywords: [
       "agent-swarm.dev",
@@ -61,7 +61,7 @@ var init_package = __esm(() => {
     config: {
       name: "agent-swarm"
     },
-    packageManager: "bun@1.4.3",
+    packageManager: "bun@1.4.4",
     workspaces: [
       "apps/ui",
       "apps/templates-ui",
@@ -206,10 +206,10 @@ var init_package = __esm(() => {
       bun: ">=1.3.12"
     },
     dependencies: {
-      "@agentclientprotocol/sdk": "2.0.1",
+      "@agentclientprotocol/sdk": "2.0.2",
       "@ai-sdk/openai": "^3.0.41",
-      "@anthropic-ai/claude-agent-sdk": "0.3.309",
-      "@anthropic-ai/sdk": "^1.2.0",
+      "@anthropic-ai/claude-agent-sdk": "0.3.310",
+      "@anthropic-ai/sdk": "^1.3.0",
       "@asteasolutions/zod-to-openapi": "^8.0.0",
       "@aws-sdk/client-bedrock": "3.1048.0",
       "@chat-adapter/discord": "4.41.1",

package/dist/cli-nq677csy.js

@@ -0,0 +1,140 @@
+import {
+  getKnownContextWindowSize,
+  clampContextPercent,
+  init_context_window
+} from "./cli-pfk92eqz.js";
+import {
+  resolveTemplateFromCode,
+  resolveTemplateAsync,
+  init_resolver,
+  init_session_templates
+} from "./cli-dqygeeh5.js";
+
+// src/hooks/context-bound-note.ts
+import { renameSync, writeFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+
+// src/prompts/context-bound-note.ts
+init_session_templates();
+init_resolver();
+var CONTEXT_BOUND_NOTE_TEMPLATE = "system.agent.context.bound_note";
+function contextShare(contextTokens, model) {
+  if (!model)
+    return "";
+  try {
+    init_context_window();
+    const window = getKnownContextWindowSize(model);
+    const percent = clampContextPercent(contextTokens, window);
+    if (!window || percent === null)
+      return "";
+    return ` (${Math.round(percent)}% of the ${window.toLocaleString("en-US")}-token window)`;
+  } catch {
+    return "";
+  }
+}
+async function renderContextBoundNote(contextTokens, model) {
+  const variables = {
+    contextTokens: Math.round(contextTokens).toLocaleString("en-US"),
+    contextShare: contextShare(contextTokens, model)
+  };
+  try {
+    const result = await resolveTemplateAsync(CONTEXT_BOUND_NOTE_TEMPLATE, variables);
+    return result.skipped ? "" : result.text;
+  } catch {
+    return resolveTemplateFromCode(CONTEXT_BOUND_NOTE_TEMPLATE, variables).text;
+  }
+}
+
+// src/hooks/context-bound-note.ts
+function contextBoundNoteThreshold(env = process.env) {
+  const raw = env.CONTEXT_BOUND_NOTE_TOKENS?.trim();
+  if (!raw || !/^\d+$/.test(raw))
+    return 0;
+  const parsed = Number(raw);
+  return Number.isSafeInteger(parsed) ? parsed : 0;
+}
+function reachesThreshold(contextTokens, threshold) {
+  return threshold > 0 && typeof contextTokens === "number" && Number.isFinite(contextTokens) && contextTokens >= threshold;
+}
+async function deliverContextBoundNote(contextTokens, model, inject) {
+  try {
+    const note = await renderContextBoundNote(contextTokens, model);
+    if (note)
+      await inject(note);
+  } catch {}
+}
+function contextStatePath(taskFilePath) {
+  return `${taskFilePath}.context.json`;
+}
+function contextBoundNoteMarkerPath(taskFilePath) {
+  return `${taskFilePath}.bound-note`;
+}
+function recordContextState(taskFilePath, contextTokens, model) {
+  const path = contextStatePath(taskFilePath);
+  const tmp = `${path}.tmp`;
+  try {
+    writeFileSync(tmp, JSON.stringify({ contextTokens, model, updatedAt: new Date().toISOString() }));
+    renameSync(tmp, path);
+  } catch {}
+}
+async function claimContextBoundNote(taskFilePath, threshold) {
+  if (!taskFilePath || threshold <= 0)
+    return null;
+  let contextTokens;
+  let model;
+  try {
+    const state = JSON.parse(await readFile(contextStatePath(taskFilePath), "utf8"));
+    contextTokens = state?.contextTokens;
+    model = state?.model;
+  } catch {
+    return null;
+  }
+  if (!reachesThreshold(contextTokens, threshold))
+    return null;
+  try {
+    await writeFile(contextBoundNoteMarkerPath(taskFilePath), new Date().toISOString(), {
+      flag: "wx"
+    });
+  } catch {
+    return null;
+  }
+  return { contextTokens, model: typeof model === "string" && model ? model : undefined };
+}
+async function injectClaimedContextBoundNote(taskFilePath, threshold, inject) {
+  const state = await claimContextBoundNote(taskFilePath, threshold).catch(() => null);
+  if (state)
+    await deliverContextBoundNote(state.contextTokens, state.model, inject);
+}
+function createContextBoundNote(options) {
+  let state = "idle";
+  let held = "";
+  const tryDeliver = async (note) => {
+    try {
+      if (!options.canDeliver()) {
+        held = note;
+        state = "held";
+        return;
+      }
+      state = "done";
+      await options.inject(note);
+    } catch {}
+  };
+  return async (contextTokens) => {
+    if (state === "held")
+      return tryDeliver(held);
+    if (state !== "idle" || !reachesThreshold(contextTokens, options.threshold))
+      return;
+    state = "rendering";
+    let note = "";
+    try {
+      note = await renderContextBoundNote(contextTokens, options.model?.());
+    } catch {}
+    if (!note) {
+      state = "done";
+      return;
+    }
+    await tryDeliver(note);
+  };
+}
+
+export { contextBoundNoteThreshold, contextStatePath, contextBoundNoteMarkerPath, recordContextState, injectClaimedContextBoundNote, createContextBoundNote };

package/dist/{cli-a5ebc95n.js → cli-pfk92eqz.js}

@@ -2,21 +2,19 @@ import {
   runtimeCatalogSection,
   runtimeCatalogModel,
   init_runtime_model_catalog
-} from "./cli-6x9ma5w5.js";
+} from "./cli-803188pb.js";
 import {
   buildClaudeShortnameMap,
   init_src2
-} from "./cli-nwyw3zhg.js";
+} from "./cli-gxee0bqa.js";
+import {
+  __esm
+} from "./cli-242037k3.js";
 
 // src/utils/context-window.ts
-init_src2();
-init_runtime_model_catalog();
-var CONTEXT_FORMULA = "input-cache-output";
-var DEFAULT_CONTEXT_WINDOW = 200000;
 function stripAnthropicDateSuffix(model) {
   return model.replace(/-(\d{8})$/, "");
 }
-var shortnameMap = null;
 function resolveClaudeShortname(model) {
   const section = runtimeCatalogSection("anthropic");
   if (!shortnameMap || shortnameMap.section !== section) {
@@ -29,8 +27,11 @@ function catalogContext(provider, model) {
   return typeof context === "number" && context > 0 ? context : undefined;
 }
 function getContextWindowSize(model) {
+  return getKnownContextWindowSize(model) ?? DEFAULT_CONTEXT_WINDOW;
+}
+function getKnownContextWindowSize(model) {
   if (!model)
-    return DEFAULT_CONTEXT_WINDOW;
+    return;
   const slash = model.indexOf("/");
   if (slash > 0) {
     const scoped = catalogContext(model.slice(0, slash), model.slice(slash + 1));
@@ -49,12 +50,9 @@ function getContextWindowSize(model) {
       return dated;
   }
   const shortname = resolveClaudeShortname(model);
-  if (shortname) {
-    const resolved = catalogContext("anthropic", shortname);
-    if (resolved)
-      return resolved;
-  }
-  return DEFAULT_CONTEXT_WINDOW;
+  if (shortname)
+    return catalogContext("anthropic", shortname);
+  return;
 }
 function computeContextUsedUnified(parts) {
   return (parts.inputTokens ?? 0) + (parts.cacheReadTokens ?? 0) + (parts.cacheCreateTokens ?? 0) + (parts.outputTokens ?? 0);
@@ -67,5 +65,10 @@ function clampContextPercent(used, total) {
     return null;
   return Math.min(100, Math.max(0, raw));
 }
+var CONTEXT_FORMULA = "input-cache-output", DEFAULT_CONTEXT_WINDOW = 200000, shortnameMap = null;
+var init_context_window = __esm(() => {
+  init_src2();
+  init_runtime_model_catalog();
+});
 
-export { CONTEXT_FORMULA, getContextWindowSize, computeContextUsedUnified, clampContextPercent };
+export { CONTEXT_FORMULA, getContextWindowSize, getKnownContextWindowSize, computeContextUsedUnified, clampContextPercent, init_context_window };