@desplega.ai/agent-swarm 2.5.4 → 2.6.0

package/src/utils/provider-key-probes.ts

@@ -0,0 +1,328 @@
+/** Shared credential probes. This module does not import worker harnesses. */
+import {
+  type OpenAICompatibleProvider,
+  providerBaseUrl,
+  providerForKeyVar,
+} from "@desplega/model-catalog";
+import {
+  createScopedFetch,
+  deriveDefaultRoute,
+  getRouteProvider,
+  type ModelRoute,
+} from "@desplega/model-routing";
+import { assertUrlSafe, publicEndpointSsrfOptions } from "../oauth/mcp-wrapper";
+import { getOpenRouterAttributionHeaders, getOpenRouterBaseUrl } from "./openrouter-base-url";
+import { scrubSecrets } from "./secret-scrubber";
+
+interface ProbeOptions {
+  env?: Record<string, string | undefined>;
+  publicEndpoint?: boolean;
+}
+
+const LIVE_TEST_TIMEOUT_MS = 5_000;
+
+function scrubProbeBody(body: string, init: RequestInit): string {
+  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);
+}
+
+export interface LiveKeyResult {
+  keyType: string;
+  index: number;
+  suffix: string;
+  ok: boolean;
+  error?: string;
+  httpStatus?: number;
+  latency_ms: number;
+}
+
+export interface LiveValidationResult {
+  ok: boolean;
+  error?: string;
+  httpStatus?: number;
+  warning?: string;
+  keys?: LiveKeyResult[];
+  latency_ms: number;
+  /** No free live check exists for this credential (cloud routes): report presence only. */
+  skipped?: boolean;
+}
+
+export async function timedFetch(
+  url: string,
+  init: RequestInit,
+  options: ProbeOptions = {},
+): Promise<{ ok: boolean; status: number; bodyText: string; latency_ms: number }> {
+  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 {
+      // The HTTP status is sufficient when the response body cannot be read.
+    }
+    return {
+      ok: res.ok,
+      status: res.status,
+      bodyText,
+      latency_ms: Date.now() - start,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function checkAnthropicApiKey(
+  apiKey: string,
+  options: ProbeOptions = {},
+): Promise<LiveValidationResult> {
+  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,
+  };
+}
+
+export async function checkOpenAiApiKey(
+  apiKey: string,
+  options: ProbeOptions = {},
+): Promise<LiveValidationResult> {
+  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,
+  };
+}
+
+/** `GET /v1/models` is the call the Grok CLI makes first; it runs no inference. */
+export async function checkXaiApiKey(
+  apiKey: string,
+  options: ProbeOptions = {},
+): Promise<LiveValidationResult> {
+  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,
+  };
+}
+
+/** Fetch a key-authenticated GET and normalize it into a `LiveValidationResult`. */
+async function checkBearerGet(
+  url: string,
+  init: RequestInit,
+  options: ProbeOptions = {},
+): Promise<LiveValidationResult> {
+  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,
+  };
+}
+
+/**
+ * OpenRouter's `/models` is public and answers 200 for any key, so the check
+ * reads `GET /key` (the key's own info, 401 for a bad key). A custom
+ * `OPENROUTER_BASE_URL` without `/key` (404/405) falls back to `/models`.
+ */
+export async function checkOpenRouter(
+  apiKey: string,
+  options: ProbeOptions = {},
+): Promise<LiveValidationResult> {
+  const base = getOpenRouterBaseUrl(options.env);
+  const get = (url: string) =>
+    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;
+}
+
+/** `GET /models` on the official DeepSeek API: lists models, runs no inference. */
+export function checkDeepSeekApiKey(
+  apiKey: string,
+  options: ProbeOptions = {},
+): Promise<LiveValidationResult> {
+  return checkBearerGet(
+    "https://api.deepseek.com/models",
+    {
+      headers: { Authorization: `Bearer ${apiKey}` },
+    },
+    options,
+  );
+}
+
+/**
+ * `GET <baseUrl>/models` with a Bearer key against an OpenAI-compatible
+ * registry provider (NaN, Helmcode). Lists models, runs no inference.
+ * `baseUrl` defaults to the registry entry; the probe passes the
+ * `<ID>_BASE_URL` override, and tests inject a fake server.
+ */
+export async function checkOpenAICompatibleProvider(
+  provider: OpenAICompatibleProvider,
+  apiKey: string,
+  baseUrl: string = provider.baseUrl,
+  options: ProbeOptions = {},
+): Promise<LiveValidationResult> {
+  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,
+  };
+}
+
+/**
+ * Run the route provider's own check. Requests stay on the route's origin and
+ * path prefix, go to public hosts only, and never follow a redirect.
+ */
+async function checkRoute(
+  route: ModelRoute,
+  env: Record<string, string | undefined>,
+): Promise<LiveValidationResult> {
+  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: string | URL | Request, init?: RequestInit) => {
+    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 as typeof fetch),
+  });
+  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,
+  };
+}
+
+/** Check one newly submitted pool member without loading a worker harness. */
+export async function checkProviderPoolKey(
+  keyType: string,
+  apiKey: string,
+  env: Record<string, string | undefined> = process.env,
+): Promise<LiveValidationResult> {
+  const startedAt = Date.now();
+  const options: ProbeOptions = { env, publicEndpoint: true };
+  try {
+    switch (keyType) {
+      case "ANTHROPIC_API_KEY": {
+        // Behind a gateway (`ANTHROPIC_BASE_URL`), Claude Code sends this key
+        // to the gateway, so check it there and not at api.anthropic.com.
+        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,
+    };
+  }
+}

package/src/utils/transcription.ts

@@ -20,6 +20,7 @@
  * auto-detected key always goes to its provider's own endpoint. Deepgram and AssemblyAI use other request shapes and are not
  * supported. Read at call time, so a config reload applies without a restart.
  */
+import { selectCredential } from "./credentials";
 import { createValueScrubber, scrubSecrets } from "./secret-scrubber";
 
 const TRANSCRIPTION_TIMEOUT_MS = 60_000;
@@ -119,7 +120,9 @@ export function resolveTranscriptionConfig(): TranscriptionConfig | null {
     : AUTO_DETECT_ORDER;
   for (const name of candidates) {
     const { keyEnv } = PROVIDERS[name];
-    const apiKey = envValue(keyEnv);
+    const value = envValue(keyEnv);
+    // OPENAI_API_KEY may be a comma pool: send one member.
+    const apiKey = value ? selectCredential(value, undefined, keyEnv).selected : undefined;
     if (apiKey) return { provider: name, apiKey, keyEnv, source: "auto" };
   }
   return null;

package/src/workflows/executors/sub-workflow.ts

@@ -133,7 +133,14 @@ export class SubWorkflowExecutor extends BaseExecutor<
       throw err;
     }
     const child = await db.getWorkflowRun(childRunId);
-    if (!child) return { status: "failed", error: `Child workflow run ${childRunId} not found` };
+    // The start committed the row, so a missing one was deleted with its workflow.
+    if (!child) {
+      return {
+        status: "failed",
+        error: `Child workflow run ${childRunId} not found`,
+        retryable: false,
+      };
+    }
     return this.settle(child, config.workflowId);
   }
 

package/templates/ai-toolbox.manifest.json

@@ -1,5 +1,5 @@
 {
-  "commit": "5a577022800d9b43ccec5376bfe16c7b24eecd91",
+  "commit": "c81f2bb62f49b45603e9e702558e1ca22e98fcdd",
   "excludedSkills": [
     "feedback"
   ],
@@ -44,7 +44,7 @@
     "templates/skills/questioning/content.md": "66f826a191e96d0041adca00a7c197a458de8e6fe164c1599b8708098d4109ab",
     "templates/skills/questioning/files/template.md": "a68d72801a0b10380bf773b07e9d2f8d4c5b4b1c609ce954289e38ffc78cc223",
     "templates/skills/researching/config.json": "921c062cab599097cc7677d2dad4797ec4d5844d2ee73607fbd417ec3fa487d4",
-    "templates/skills/researching/content.md": "92951142327415696726a2577defdb2379cc611cdafa9cdac92431a5e60f618f",
+    "templates/skills/researching/content.md": "87ced42d15f1fd63d1b4e8d5ed8161537202f5b05a85df38dea273e9e3d6ad08",
     "templates/skills/researching/files/template.md": "411d34b98c610ef715edf0f24d09f828ba2d0f65f688e7879ef33a9453007949",
     "templates/skills/reviewing/config.json": "09c40bb098e9738c60a848995fa9fe7568d158631a089c76ba02c0dd955445c7",
     "templates/skills/reviewing/content.md": "1bbc285c9ad8cc3312f1ee2c558b04ffee914ffb6f5c63fb3741fcbb3e300fa5",

package/templates/skills/researching/content.md

@@ -166,3 +166,5 @@ File-review is on by default (unless Autopilot):
 - Research documents should be self-contained
 - **CRITICAL**: You are a documentarian, not an evaluator
 - **REMEMBER**: Document what IS, not what SHOULD BE
+- Single-page-app blogs (Vite/MDX): the HTML and RSS carry only the title and summary. The post text is compiled into the main JS bundle (`/assets/index-<hash>.js`, referenced in the page HTML). Fetch the bundle and extract string literals with a quote-aware tokenizer started at a function boundary; a naive regex desyncs on quotes.
+- YouTube bot-blocks downloads from sandboxed egress. To describe a video, give its URL to a multimodal model. For the bytes of a brand's own product video, grep the brand's site or changelog HTML for `.mp4` URLs first and match the target by duration.

package/templates/skills/swarm-scripts/SKILL.md

@@ -175,6 +175,7 @@ function rowsToObjects(res: any): any[] {
 - `kv_get` returns the entry at `data`: read `res.data.value`. The MCP tool shape `entry.value` reads `undefined` in a script.
 - `script_run` returns an envelope (`result`, `truncated`, `durationMs`, `stdout`, `stderr`, `exitCode`). The callee payload is at `.result`. Take key names from a real response: a guessed key that is absent reads as a false zero.
 - An `argsSchema` validation error fires before the body runs and repeats on every retry. Fix the args instead of retrying.
+- The skill methods disagree on the id field: `skill_get({ id })`, but `skill_update({ skillId, content })`. `skill_update({ id, content })` returns outer `success: true` with inner `data.success: false` ("skillId is required.") and writes nothing. Gate a write on `res.data.success`, then re-read: the version must increase and the content must match the draft.
 - Write a dedup or idempotency marker only after the step succeeds. A marker written after a failure blocks the next real attempt.
 - `kv_set` returns `success: false` instead of throwing when a key has a character outside `[a-zA-Z0-9._:/-]` (for example `#` or `|` from a git ref). Check `success` after every write.
 - `script_run` without `scope` runs an agent-scoped row of the same name before the global one, so a stale private copy silently wins. Pass `scope: "global"` for a shared script.

package/templates/skills/swarm-scripts/content.md

@@ -170,6 +170,7 @@ function rowsToObjects(res: any): any[] {
 - `kv_get` returns the entry at `data`: read `res.data.value`. The MCP tool shape `entry.value` reads `undefined` in a script.
 - `script_run` returns an envelope (`result`, `truncated`, `durationMs`, `stdout`, `stderr`, `exitCode`). The callee payload is at `.result`. Take key names from a real response: a guessed key that is absent reads as a false zero.
 - An `argsSchema` validation error fires before the body runs and repeats on every retry. Fix the args instead of retrying.
+- The skill methods disagree on the id field: `skill_get({ id })`, but `skill_update({ skillId, content })`. `skill_update({ id, content })` returns outer `success: true` with inner `data.success: false` ("skillId is required.") and writes nothing. Gate a write on `res.data.success`, then re-read: the version must increase and the content must match the draft.
 - Write a dedup or idempotency marker only after the step succeeds. A marker written after a failure blocks the next real attempt.
 - `kv_set` returns `success: false` instead of throwing when a key has a character outside `[a-zA-Z0-9._:/-]` (for example `#` or `|` from a git ref). Check `success` after every write.
 - `script_run` without `scope` runs an agent-scoped row of the same name before the global one, so a stale private copy silently wins. Pass `scope: "global"` for a shared script.

package/dist/cli-7421jzsw.js

@@ -1,84 +0,0 @@
-import {
-  __esm
-} from "./cli-242037k3.js";
-
-// src/utils/model-rate-limit-windows.ts
-function modelFamilyOf(model) {
-  if (!model)
-    return;
-  const lower = model.toLowerCase();
-  const families = ["fable", "opus", "sonnet", "haiku"];
-  for (const family of families) {
-    if (lower.includes(family))
-      return family;
-  }
-  return;
-}
-function windowForModelFamily(family) {
-  switch (family) {
-    case "fable":
-      return FABLE_WINDOW;
-    case "opus":
-      return OPUS_WINDOW;
-    case "sonnet":
-      return SONNET_WINDOW;
-    default:
-      return;
-  }
-}
-function isModelScopedWindow(type) {
-  return Object.hasOwn(MODEL_SCOPED_WINDOWS, type) && MODEL_SCOPED_WINDOWS[type] !== undefined;
-}
-function parseModelLimitMessage(text) {
-  const match = text.match(/reached your (Fable|Opus|Sonnet) limit/i);
-  if (!match)
-    return;
-  return match[1].toLowerCase();
-}
-function parseCreditsRequiredMessage(text) {
-  const match = text.match(/(Fable|Opus|Sonnet)(?:[^.]|\.(?=\d)){0,40}requires usage credits/i);
-  if (!match)
-    return;
-  return match[1].toLowerCase();
-}
-function activeModelBlock(windows, family, nowMs) {
-  if (!windows)
-    return;
-  const window = windowForModelFamily(family);
-  if (!window)
-    return;
-  const entry = windows[window];
-  if (!entry)
-    return;
-  if (entry.status !== "rejected")
-    return;
-  if (typeof entry.resetsAt !== "number" || entry.resetsAt * 1000 <= nowMs)
-    return;
-  return { window, resetsAt: entry.resetsAt };
-}
-function activeModelBlocks(windows, nowMs) {
-  if (!windows)
-    return [];
-  const blocks = [];
-  for (const [window, model] of Object.entries(MODEL_SCOPED_WINDOWS)) {
-    const entry = windows[window];
-    if (!entry)
-      continue;
-    if (entry.status !== "rejected")
-      continue;
-    if (typeof entry.resetsAt !== "number" || entry.resetsAt * 1000 <= nowMs)
-      continue;
-    blocks.push({ model, window, resetsAt: entry.resetsAt });
-  }
-  return blocks;
-}
-var FABLE_WINDOW = "seven_day_overage_included", OPUS_WINDOW = "seven_day_opus", SONNET_WINDOW = "seven_day_sonnet", MODEL_SCOPED_WINDOWS;
-var init_model_rate_limit_windows = __esm(() => {
-  MODEL_SCOPED_WINDOWS = {
-    [FABLE_WINDOW]: "fable",
-    [OPUS_WINDOW]: "opus",
-    [SONNET_WINDOW]: "sonnet"
-  };
-});
-
-export { MODEL_SCOPED_WINDOWS, modelFamilyOf, windowForModelFamily, isModelScopedWindow, parseModelLimitMessage, parseCreditsRequiredMessage, activeModelBlock, activeModelBlocks, init_model_rate_limit_windows };