@desplega.ai/agent-swarm 2.4.4 → 2.4.5

package/src/workflows/executors/system-one-providers.ts

@@ -288,15 +288,41 @@ export const SYSTEM_ONE_PROVIDERS = Object.fromEntries(
 export const SYSTEM_ONE_PROVIDER_IDS = hostsServing("decide");
 export const SYSTEM_ONE_EXTRACT_PROVIDER_IDS = hostsServing("extract");
 
+/** The decision provider when neither the call nor `SYSTEM_ONE_DEFAULT_PROVIDER` names one. */
 export const SYSTEM_ONE_DEFAULT_PROVIDER: SystemOneProviderId = "typesafe";
 export const SYSTEM_ONE_EXTRACT_DEFAULT_PROVIDER: SystemOneExtractProviderId = "cloudflare";
 
+/** Global config key naming the decision provider a node or call without `provider` uses. */
+export const SYSTEM_ONE_DEFAULT_PROVIDER_CONFIG_KEY = "SYSTEM_ONE_DEFAULT_PROVIDER";
+
 export function isSystemOneProviderId(value: unknown): value is SystemOneProviderId {
   return (
     typeof value === "string" && (SYSTEM_ONE_PROVIDER_IDS as readonly string[]).includes(value)
   );
 }
 
+/**
+ * The decision provider for a node or call that names none: the global
+ * `SYSTEM_ONE_DEFAULT_PROVIDER` row, then the same key in the environment, then
+ * `typesafe`. Read at run time, so changing the setting needs no workflow edit.
+ * A value that is not a decide host is skipped; the config guard refuses it on save.
+ */
+export async function resolveSystemOneDefaultProvider(
+  ctx: SystemOneProviderContext,
+): Promise<SystemOneProviderId> {
+  let stored: string | undefined;
+  try {
+    stored = await readGlobalConfig(ctx.db, SYSTEM_ONE_DEFAULT_PROVIDER_CONFIG_KEY);
+  } catch {
+    // An unreadable row falls back like an unset one: the default stays usable.
+  }
+  for (const raw of [stored, ctx.env[SYSTEM_ONE_DEFAULT_PROVIDER_CONFIG_KEY]]) {
+    const id = raw?.trim().toLowerCase();
+    if (isSystemOneProviderId(id)) return id;
+  }
+  return SYSTEM_ONE_DEFAULT_PROVIDER;
+}
+
 export function isSystemOneExtractProviderId(value: unknown): value is SystemOneExtractProviderId {
   return (
     typeof value === "string" &&
@@ -304,11 +330,15 @@ export function isSystemOneExtractProviderId(value: unknown): value is SystemOne
   );
 }
 
-/** Provider a raw node config selects. Undefined when the field is present but not a known id. */
+/**
+ * Provider a raw node config selects, `defaultId` when it names none. Undefined
+ * when the field is present but not a known id.
+ */
 export function systemOneProviderOf(
   config: Record<string, unknown>,
+  defaultId: SystemOneProviderId = SYSTEM_ONE_DEFAULT_PROVIDER,
 ): SystemOneProviderId | undefined {
-  if (config.provider === undefined) return SYSTEM_ONE_DEFAULT_PROVIDER;
+  if (config.provider === undefined) return defaultId;
   return isSystemOneProviderId(config.provider) ? config.provider : undefined;
 }
 
@@ -489,7 +519,12 @@ export type SystemOneTarget =
       /** The secret name the key was read under, for a rejection message. */
       keyName: string;
     }
-  | { ok: false; error: string };
+  | {
+      ok: false;
+      error: string;
+      /** This deployment refuses the host whatever its credential (`deploymentProblem`). */
+      deploymentRefused?: true;
+    };
 
 export interface SystemOneTargetOverrides {
   /** Replaces the credential lookup. */
@@ -517,7 +552,7 @@ export async function resolveSystemOneTarget(
   const capability = overrides.capability ?? "decide";
   const service = serviceOf(id, capability);
   const deploymentProblem = host.deploymentProblem?.(ctx.env);
-  if (deploymentProblem) return { ok: false, error: deploymentProblem };
+  if (deploymentProblem) return { ok: false, error: deploymentProblem, deploymentRefused: true };
 
   const errors: string[] = [];
 

package/templates/extensions/slack-reply-gate/README.md

@@ -1,6 +1,6 @@
 # slack-reply-gate
 
-Lead is woken by every human message in a Slack thread the swarm takes part in, including "lol", an emoji, or two people chatting with each other. This extension asks Jev, [TypeSafe](https://typesafe.ai)'s decision model, whether Lead should answer a new thread message, and drops the wake-up when it should not.
+Lead is woken by every human message in a Slack thread the swarm takes part in, including "lol", an emoji, or two people chatting with each other. This extension asks a SystemOne decision model, Jev ([TypeSafe](https://typesafe.ai)) or Clef (Cloudflare Workers AI), whether Lead should answer a new thread message, and drops the wake-up when it should not.
 
 Install config:
 
@@ -15,8 +15,8 @@ Start in `shadow`, read the decisions in KV for a few days, then switch to `enfo
 | `mode` | Effect |
 |---|---|
 | `off` | Never evaluates. |
-| `shadow` (default) | Asks Jev and records the verdict. Never blocks. |
-| `enforce` | Asks Jev, records the verdict, and blocks the Lead task when the answer is no. The message gets :mute: instead: no Lead task, no reply, no outcome card. |
+| `shadow` (default) | Asks the model and records the verdict. Never blocks. |
+| `enforce` | Asks the model, records the verdict, and blocks the Lead task when the answer is no. The message gets :mute: instead: no Lead task, no reply, no outcome card. |
 
 ## What it gates
 
@@ -26,28 +26,30 @@ The header counts only at the start of the description or right after the closin
 
 ## Decision
 
-1. A follow-up with downloaded files (status `draft`) passes without a Jev call.
-2. **@mention pass-through.** A new message that @mentions Lead passes without a Jev call. A mention is the bot mention the engine rewrites to `<@U…> (that's you)`, a resolved `<@U…|lead>`, or a literal `@lead` (any name in `leadAliases`). Only the new messages are scanned, never the thread context, so an old mention earlier in the thread does not pass later banter.
-3. Otherwise one Jev call (one `choice` question, see [Jev transport](#jev-transport)) with the new message(s), the sender kind, and the last `contextMessages` thread messages. Labels: `direct_ask`, `followup_to_lead`, `instruction_to_lead`, `reaction_only`, `banter_between_others`, `not_addressed_to_lead`, `other`.
+1. A follow-up with downloaded files (status `draft`) passes without a decision call.
+2. **@mention pass-through.** A new message that @mentions Lead passes without a decision call. A mention is the bot mention the engine rewrites to `<@U…> (that's you)`, a resolved `<@U…|lead>`, or a literal `@lead` (any name in `leadAliases`). Only the new messages are scanned, never the thread context, so an old mention earlier in the thread does not pass later banter.
+3. Otherwise one decision call (one `choice` question, see [Provider](#provider)) with the new message(s), the sender kind, and the last `contextMessages` thread messages. Labels: `direct_ask`, `followup_to_lead`, `instruction_to_lead`, `reaction_only`, `banter_between_others`, `not_addressed_to_lead`, `other`.
 4. The answer is no only when the top label is `reaction_only`, `banter_between_others`, or `not_addressed_to_lead`, and the summed probability of those three labels is at least `minConfidence`. A split between two skip labels is still a skip. An unsure verdict replies.
 
 Several buffered messages are judged together. One mention in any of them passes the batch.
 
-## Jev transport
+## Provider
 
-Jev is reachable two ways. Both take the same request and return the same answer, so the decision is identical whichever one runs.
+The decision is made on the API server by the `system-one-decide` tool (`ctx.swarm.systemOne_decide`), the same path a `system-one-decision` workflow node takes. The server reads the provider's credential, sends the request, and validates the answer, so every SystemOne host works and no key enters the hook.
 
-| `provider` | Endpoint | Key | Model |
-|---|---|---|---|
-| `typesafe` | `POST https://api.typesafe.ai/v1/systemone` | `TYPESAFE_API_KEY` (or `apiKey`) | `model`, default `jev-latest` |
-| `openrouter` | `POST https://openrouter.ai/api/alpha/decisions` | `OPENROUTER_API_KEY` | `openrouterModel`, default `typesafe/jev-1.13` |
-| `auto` (default) | TypeSafe when its key is set, else OpenRouter | | |
+| `provider` | Model | Credential |
+|---|---|---|
+| `typesafe` | Jev, `model` (default `jev-latest`) | `TYPESAFE_API_KEY` |
+| `openrouter` | Jev, `openrouterModel` (default `typesafe/jev-1.13`) | `OPENROUTER_API_KEY` |
+| `cloudflare` | Clef, `cloudflareModel` (default `clef`, or `clef-flash`) | `CLOUDFLARE_API_TOKEN` (or `CLOUDFLARE_API_KEY`) and `CLOUDFLARE_ACCOUNT_ID` |
+| `laya`, `openai` | The host's default model | See the workflows guide |
+| `auto` (default) | The first of typesafe, openrouter, cloudflare whose credential is set. A provider the server refuses for a deployment setting (openrouter when `OPENROUTER_BASE_URL` points at a gateway) is skipped for the next one | |
 
-Under `auto`, `TYPESAFE_API_KEY` wins when both keys are set. With neither key, every message fails open and the KV row names both secrets. Each decision row records the `provider` that answered.
+With no credential for `auto`, every message fails open and the KV row names the secrets. Each decision row records the `provider` that answered. `minConfidence` was tuned on Jev; check Clef's verdicts in `shadow` before you enforce on it.
 
 ## Fail open
 
-Every error lets the task through: a missing key, a TypeSafe HTTP error, a network error, a timeout, a malformed answer, or an unknown label. The handler never throws, so an outage cannot auto-disable the extension. Each failure is recorded as `fail-open` in KV and logged as a warning.
+Every error lets the task through: a missing key, a provider error relayed by the server, a network error, a timeout, a malformed answer, or an unknown label. The handler never throws, so an outage cannot auto-disable the extension. Each failure is recorded as `fail-open` in KV and logged as a warning.
 
 ## :mute: on drop (enforce)
 
@@ -63,23 +65,23 @@ The block returns first and the Slack calls run after it. A slow or failing Slac
 | Key | Default | Notes |
 |---|---|---|
 | `mode` | `shadow` | `off`, `shadow`, or `enforce` |
-| `timeoutMs` | `3000` | Jev call timeout, capped at 4000 (the dispatcher cancels a handler at 5 s) |
-| `provider` | `auto` | `auto`, `typesafe`, or `openrouter`. See [Jev transport](#jev-transport) |
+| `timeoutMs` | `3000` | Decision call timeout, capped at 4000 (the dispatcher cancels a handler at 5 s) |
+| `provider` | `auto` | `auto`, `typesafe`, `openrouter`, `cloudflare`, `laya`, or `openai`. See [Provider](#provider) |
 | `model` | `jev-latest` | Jev model on TypeSafe |
 | `openrouterModel` | `typesafe/jev-1.13` | Jev model on OpenRouter |
+| `cloudflareModel` | `clef` | Clef model on Cloudflare Workers AI |
 | `minConfidence` | `0.55` | Minimum summed skip probability to skip |
-| `contextMessages` | `6` | Thread messages sent to Jev, 0 to 20 |
+| `contextMessages` | `6` | Thread messages sent to the model, 0 to 20 |
 | `leadAliases` | `["lead"]` | A literal `@alias` in a new message counts as a mention |
-| `botSlackUserIds` | `[]` | Slack user ids labelled `bot` as the sender for Jev |
-| `apiKey` | unset | Explicit TypeSafe key. Prefer the `TYPESAFE_API_KEY` secret below |
+| `botSlackUserIds` | `[]` | Slack user ids labelled `bot` as the sender for the model |
 | `muteReaction` | `mute` | Reaction for a dropped message; `""` only removes the acceptance reaction(s) |
 | `slackTimeoutMs` | `5000` | Timeout per Slack call |
 
 ## Required secrets
 
-All are read from the API process environment at call time. Set them as global `swarm_config` secrets: the API process loads global rows into `process.env` at boot and on config reload.
+Set them as global `swarm_config` values. The server reads the provider credential from the global row when it makes the decision. `auto` and the Slack token read the API process environment, which loads global rows at boot and on config reload.
 
-- `TYPESAFE_API_KEY` or `OPENROUTER_API_KEY`: one is required for any evaluation. Under `auto`, TypeSafe wins when both are set. Without either, every message fails open.
+- One provider credential from the [Provider](#provider) table is required for any evaluation. Without one, every message fails open. The `apiKey` config field of earlier versions is gone: the hook never holds a key, so store it as the global `TYPESAFE_API_KEY` secret.
 - `SLACK_BOT_TOKEN`: the Slack app's bot token. A swarm with Slack connected already has it. Without it, `enforce` still drops the message but cannot touch its reactions, and logs a `mute-error`.
 
 No key is written to config, KV, logs, or a description.

package/templates/extensions/slack-reply-gate/hooks.ts

@@ -6,8 +6,9 @@ import { z } from "zod";
  *
  * Every human message in a Slack thread the swarm takes part in is buffered and
  * flushed into a Lead task ("[Thread follow-up — N message(s) buffered]"), even
- * "lol", ":joy:" or two people bantering. This hook asks TypeSafe Jev whether
- * Lead should answer, and drops the wake-up when the answer is no.
+ * "lol", ":joy:" or two people bantering. This hook asks a SystemOne decision
+ * model (Jev or Clef) whether Lead should answer, and drops the wake-up when the
+ * answer is no.
  *
  * Hook: `pre.task.create`, origin "slack", description carrying the
  * thread-buffer header. `pre.slack.route` cannot be used: the buffered thread
@@ -15,17 +16,20 @@ import { z } from "zod";
  * re-target a message, never drop it.
  *
  * Rules:
- *   - A message that @mentions Lead passes without a Jev call.
- *   - Otherwise one Jev `choice` question classifies the message into a reason;
+ *   - A message that @mentions Lead passes without a decision call.
+ *   - Otherwise one `choice` question classifies the message into a reason;
  *     reply=false only for reaction_only | banter_between_others |
  *     not_addressed_to_lead, and only when the summed probability of those
  *     three labels is >= minConfidence (a banter/reaction split is still a skip).
  *   - Fails OPEN on every error, timeout or missing key.
  *
- * Transport (config.provider): Jev is served by TypeSafe directly and by
- * OpenRouter's Decisions endpoint. Both take the same {model, state, questions}
- * body and return the same `answers` shape. `auto` uses TYPESAFE_API_KEY when
- * set, else OPENROUTER_API_KEY.
+ * Provider (config.provider): the decision is made server-side by the
+ * `system-one-decide` tool (`ctx.swarm.systemOne_decide`), the same path as a
+ * `system-one-decision` workflow node, so every SystemOne host works and no key
+ * enters this hook. `auto` picks the first host with a configured credential:
+ * typesafe (Jev, TYPESAFE_API_KEY), openrouter (Jev, OPENROUTER_API_KEY), then
+ * cloudflare (Clef, CLOUDFLARE_API_TOKEN or CLOUDFLARE_API_KEY, plus
+ * CLOUDFLARE_ACCOUNT_ID). laya and openai are explicit choices only.
  *
  * modes (config.mode):
  *   off     -> never evaluate
@@ -48,17 +52,19 @@ import { z } from "zod";
 export const config = z.object({
   mode: z.enum(["off", "shadow", "enforce"]).default("shadow"),
   timeoutMs: z.number().int().positive().default(3000),
-  provider: z.enum(["auto", "typesafe", "openrouter"]).default("auto"),
-  /** Jev model on the TypeSafe transport. */
+  provider: z
+    .enum(["auto", "typesafe", "openrouter", "cloudflare", "laya", "openai"])
+    .default("auto"),
+  /** Jev model on TypeSafe. */
   model: z.string().default("jev-latest"),
-  /** Jev model on the OpenRouter transport. */
+  /** Jev model on OpenRouter. */
   openrouterModel: z.string().default("typesafe/jev-1.13"),
+  /** Clef model on Cloudflare Workers AI: clef or clef-flash. */
+  cloudflareModel: z.string().default("clef"),
   minConfidence: z.number().min(0).max(1).default(0.55),
   contextMessages: z.number().int().min(0).max(20).default(6),
   leadAliases: z.array(z.string()).default(["lead"]),
   botSlackUserIds: z.array(z.string()).default([]),
-  /** Explicit TypeSafe key; otherwise TYPESAFE_API_KEY from the API process env. */
-  apiKey: z.string().optional(),
   /**
    * Reaction for a dropped message in enforce mode. "" only removes the bot's
    * acceptance reaction(s) and adds nothing.
@@ -71,13 +77,13 @@ type Cfg = z.infer<typeof config>;
 type Swarm = ApiCtx["swarm"];
 
 const NS = "ext:slack-reply-gate";
-const TYPESAFE_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
-const OPENROUTER_ENDPOINT = "https://openrouter.ai/api/alpha/decisions";
 const HEADER_LINE_RE = /(?:^|\n)\[Thread follow-up — \d+ message\(s\) buffered\]\n/g;
 const CTX_OPEN = "<thread_context>";
 const CTX_CLOSE = "</thread_context>";
 // The dispatcher cancels a handler after 5 s; leave room for the KV writes.
 const MAX_TIMEOUT_MS = 4000;
+// The smallest time budget system-one-decide accepts.
+const MIN_DECIDE_TIMEOUT_MS = 1000;
 
 export const REASONS = {
   direct_ask:
@@ -179,14 +185,14 @@ const usable = (v: string): boolean => Boolean(v) && !v.startsWith("[REDACTED");
 const envOf = (name: string): string => String(process.env[name] ?? "");
 
 /**
- * Resolve a secret: explicit value, then the API process env. The API process loads
- * global swarm_config rows into process.env at boot and on config reload.
+ * Resolve a secret from the API process env. The API process loads global
+ * swarm_config rows into process.env at boot and on config reload.
  * ctx.swarm.config_get cannot serve it: the SDK scrubs secrets to "[REDACTED:<name>]".
  */
-const secret = (name: string, explicit?: string): string => {
+const secret = (name: string): string => {
   const cached = secretCache.get(name);
   if (cached && Date.now() - cached.at < KEY_TTL_MS) return cached.value;
-  const value = [String(explicit ?? ""), envOf(name)].find(usable) ?? "";
+  const value = usable(envOf(name)) ? envOf(name) : "";
   if (usable(value)) secretCache.set(name, { value, at: Date.now() });
   return value;
 };
@@ -196,46 +202,51 @@ export const resetKeyCache = (): void => {
   secretCache.clear();
 };
 
-export type JevTransport = {
-  provider: "typesafe" | "openrouter";
-  endpoint: string;
-  key: string;
-  model: string;
-};
+export type ProviderId = Exclude<Cfg["provider"], "auto">;
+
+/** Where the decision is made. No model means the provider's own default. */
+export type DecisionTarget = { provider: ProviderId; model?: string };
+
+/** What `auto` needs per provider: every group must have one usable value. */
+const AUTO_CREDENTIALS: ReadonlyArray<[ProviderId, string[][]]> = [
+  ["typesafe", [["TYPESAFE_API_KEY"]]],
+  ["openrouter", [["OPENROUTER_API_KEY"]]],
+  ["cloudflare", [["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_API_KEY"], ["CLOUDFLARE_ACCOUNT_ID"]]],
+];
+
+const modelFor = (provider: ProviderId, cfg: Cfg): string | undefined =>
+  provider === "typesafe"
+    ? cfg.model
+    : provider === "openrouter"
+      ? cfg.openrouterModel
+      : provider === "cloudflare"
+        ? cfg.cloudflareModel
+        : undefined;
 
 /**
- * Pick the Jev transport. `auto` prefers TypeSafe and falls back to OpenRouter.
- * Throws when the chosen provider has no usable key; the handler fails open.
+ * The decision providers to try, in order. An explicit one is used as is: the
+ * server checks its credential. `auto` lists every provider in `AUTO_CREDENTIALS`
+ * whose credential is set and throws when none is; the handler then fails open.
  */
-export const resolveTransport = (cfg: Cfg): JevTransport => {
-  const typesafe = (): JevTransport | null => {
-    const key = secret("TYPESAFE_API_KEY", cfg.apiKey);
-    return usable(key)
-      ? { provider: "typesafe", endpoint: TYPESAFE_ENDPOINT, key, model: cfg.model }
-      : null;
-  };
-  const openrouter = (): JevTransport | null => {
-    const key = secret("OPENROUTER_API_KEY");
-    return usable(key)
-      ? { provider: "openrouter", endpoint: OPENROUTER_ENDPOINT, key, model: cfg.openrouterModel }
-      : null;
-  };
-  const transport =
-    cfg.provider === "typesafe"
-      ? typesafe()
-      : cfg.provider === "openrouter"
-        ? openrouter()
-        : (typesafe() ?? openrouter());
-  if (transport) return transport;
+export const resolveProviders = (cfg: Cfg): DecisionTarget[] => {
+  if (cfg.provider !== "auto") {
+    return [{ provider: cfg.provider, model: modelFor(cfg.provider, cfg) }];
+  }
+  const targets = AUTO_CREDENTIALS.filter(([, groups]) =>
+    groups.every((keys) => keys.some((key) => usable(secret(key)))),
+  ).map(([provider]) => ({ provider, model: modelFor(provider, cfg) }));
+  if (targets.length > 0) return targets;
   throw new Error(
-    cfg.provider === "typesafe"
-      ? "no TYPESAFE_API_KEY"
-      : cfg.provider === "openrouter"
-        ? "no OPENROUTER_API_KEY"
-        : "no TYPESAFE_API_KEY or OPENROUTER_API_KEY",
+    "no TYPESAFE_API_KEY, OPENROUTER_API_KEY, or CLOUDFLARE_API_TOKEN with CLOUDFLARE_ACCOUNT_ID",
   );
 };
 
+/** The first provider `resolveProviders` would try. */
+export const resolveProvider = (cfg: Cfg): DecisionTarget => resolveProviders(cfg)[0]!;
+
+/** The server refused the provider for a deployment setting and sent nothing. */
+export class ProviderUnavailableError extends Error {}
+
 const SLACK_API = "https://slack.com/api";
 // The engine's acceptance reactions (src/slack/reaction-shortcode.ts), by config key.
 const ACCEPTANCE_REACTIONS: ReadonlyArray<[string, string]> = [
@@ -323,7 +334,7 @@ export const settleMutes = async (): Promise<void> => {
   await Promise.allSettled([...pendingMutes]);
 };
 
-export type JevVerdict = {
+export type Verdict = {
   reason: string;
   confidence: number | null;
   probabilities: Record<string, number> | null;
@@ -331,56 +342,73 @@ export type JevVerdict = {
 };
 
 /**
- * One Jev call: classify the newest message into a reason. Throws on any failure.
- * TypeSafe and OpenRouter share the request body and the `answers` response shape.
+ * One decision: classify the newest message into a reason. Throws on any failure.
+ * The server makes the call (`system-one-decide`), so every provider returns the
+ * same `answers` shape. The time budget is enforced here and on the server.
  */
-export const askJev = async (
+export const askModel = async (
+  swarm: Swarm,
   input: {
     messages: string[];
     context: string[];
     sender: string;
     leadNames: readonly string[];
   },
-  transport: JevTransport,
+  target: DecisionTarget,
   cfg: Cfg,
   outer?: AbortSignal,
-): Promise<JevVerdict> => {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), Math.min(cfg.timeoutMs, MAX_TIMEOUT_MS));
-  const onOuterAbort = () => controller.abort();
-  outer?.addEventListener("abort", onOuterAbort);
+): Promise<Verdict> => {
+  const budgetMs = Math.min(cfg.timeoutMs, MAX_TIMEOUT_MS);
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let onOuterAbort: (() => void) | undefined;
+  const stop = new Promise<never>((_resolve, reject) => {
+    timer = setTimeout(() => reject(new Error(`timed out after ${budgetMs}ms`)), budgetMs);
+    onOuterAbort = () => reject(new Error("aborted"));
+    outer?.addEventListener("abort", onOuterAbort);
+  });
   const t0 = Date.now();
   try {
-    const res = await fetch(transport.endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${transport.key}`,
+    const call = swarm.systemOne_decide({
+      provider: target.provider,
+      ...(target.model ? { model: target.model } : {}),
+      state: {
+        role: "Decide whether Lead, the coordinating AI agent of a team's agent swarm, should answer a new Slack message in a thread it takes part in. Lead is woken by every message in the thread, including ones not meant for it. Answering noise wastes everyone's time; missing a real ask is worse.",
+        lead_names: [...input.leadNames],
+        recent_thread_messages: input.context,
+        new_message: input.messages.join("\n---\n"),
+        new_message_sender: input.sender,
       },
-      body: JSON.stringify({
-        state: {
-          role: "Decide whether Lead, the coordinating AI agent of a team's agent swarm, should answer a new Slack message in a thread it takes part in. Lead is woken by every message in the thread, including ones not meant for it. Answering noise wastes everyone's time; missing a real ask is worse.",
-          lead_names: input.leadNames,
-          recent_thread_messages: input.context,
-          new_message: input.messages.join("\n---\n"),
-          new_message_sender: input.sender,
-        },
-        model: transport.model,
-        questions: {
-          reason: {
-            type: "choice",
-            instructions:
-              "Which label best describes new_message from Lead's point of view? Use recent_thread_messages to tell who it is talking to. Lines starting with [Agent] are swarm bots.",
-            criteria: REASONS,
-          },
+      questions: {
+        reason: {
+          type: "choice",
+          instructions:
+            "Which label best describes new_message from Lead's point of view? Use recent_thread_messages to tell who it is talking to. Lines starting with [Agent] are swarm bots.",
+          criteria: REASONS,
         },
-      }),
-      signal: controller.signal,
+      },
+      timeoutMs: Math.max(budgetMs, MIN_DECIDE_TIMEOUT_MS),
+      maxRetries: 0,
     });
-    if (!res.ok) throw new Error(`${transport.provider} ${res.status}`);
-    const body = (await res.json()) as {
+    // After a timeout nobody awaits the call; its late failure must not go unhandled.
+    call.catch(() => {});
+    const res = (await Promise.race([call, stop])) as {
+      success?: boolean;
+      status?: number;
+      data?: unknown;
+    } | null;
+    const body = (res?.data ?? res) as {
+      success?: boolean;
+      message?: unknown;
+      error?: unknown;
+      providerUnavailable?: unknown;
       answers?: { reason?: { choice?: unknown; confidence?: unknown; probabilities?: unknown } };
     } | null;
+    if (res?.success === false || body?.success === false) {
+      const why = `${target.provider}: ${String(body?.message ?? body?.error ?? `HTTP ${res?.status}`).slice(0, 200)}`;
+      throw body?.providerUnavailable === true
+        ? new ProviderUnavailableError(why)
+        : new Error(why);
+    }
     const answer = body?.answers?.reason;
     const reason = typeof answer?.choice === "string" ? answer.choice : "";
     if (!(reason in REASONS)) throw new Error(`unexpected choice: ${String(reason).slice(0, 60)}`);
@@ -392,12 +420,34 @@ export const askJev = async (
     return { reason, confidence, probabilities, latencyMs: Date.now() - t0 };
   } finally {
     clearTimeout(timer);
-    outer?.removeEventListener("abort", onOuterAbort);
+    if (onOuterAbort) outer?.removeEventListener("abort", onOuterAbort);
   }
 };
 
+/**
+ * `askModel` on each target in turn, moving on only when the server refused the
+ * provider for a deployment setting (no request was sent). Any other failure, or
+ * a refusal of the last target, throws.
+ */
+export const askFirstAvailable = async (
+  swarm: Swarm,
+  input: Parameters<typeof askModel>[1],
+  targets: readonly DecisionTarget[],
+  cfg: Cfg,
+  outer?: AbortSignal,
+): Promise<{ verdict: Verdict; target: DecisionTarget }> => {
+  for (const [i, target] of targets.entries()) {
+    try {
+      return { verdict: await askModel(swarm, input, target, cfg, outer), target };
+    } catch (err) {
+      if (!(err instanceof ProviderUnavailableError) || i === targets.length - 1) throw err;
+    }
+  }
+  throw new Error("no decision provider");
+};
+
 /** Probability that the message needs no reply: the summed mass of the skip labels. */
-export const skipProbability = (verdict: JevVerdict): number | null => {
+export const skipProbability = (verdict: Verdict): number | null => {
   if (verdict.probabilities) {
     let sum = 0;
     for (const [label, p] of Object.entries(verdict.probabilities)) {
@@ -408,9 +458,9 @@ export const skipProbability = (verdict: JevVerdict): number | null => {
   return verdict.confidence;
 };
 
-/** Map a Jev verdict to the typed decision. An unsure skip verdict replies. */
+/** Map a verdict to the typed decision. An unsure skip verdict replies. */
 export const decide = (
-  verdict: JevVerdict,
+  verdict: Verdict,
   minConfidence: number,
 ): { reply: boolean; reason: Reason; skipP: number | null; lowConfidence: boolean } => {
   const reason = verdict.reason as Reason;
@@ -507,7 +557,7 @@ const extension: SwarmExtension = (api) => {
         return;
       }
 
-      const transport = resolveTransport(cfg);
+      const targets = resolveProviders(cfg);
 
       const sender =
         opts.slackUserId && cfg.botSlackUserIds.includes(opts.slackUserId)
@@ -516,14 +566,15 @@ const extension: SwarmExtension = (api) => {
             ? "human (known teammate)"
             : "unknown (not a known teammate; may be a bot or an external person)";
 
-      const verdict = await askJev(
+      const { verdict, target } = await askFirstAvailable(
+        ctx.swarm,
         {
           messages,
           context: context.slice(-cfg.contextMessages).map((m) => m.slice(0, 500)),
           sender,
           leadNames: cfg.leadAliases,
         },
-        transport,
+        targets,
         cfg,
         ctx.signal,
       );
@@ -542,7 +593,7 @@ const extension: SwarmExtension = (api) => {
           skipP: decision.skipP,
           lowConfidence: decision.lowConfidence,
           latencyMs: verdict.latencyMs,
-          provider: transport.provider,
+          provider: target.provider,
           sender,
           preview,
         },

package/templates/extensions/slack-reply-gate/manifest.json

@@ -1,8 +1,8 @@
 {
   "$schema": "../manifest.schema.json",
   "name": "slack-reply-gate",
-  "description": "Asks Jev (TypeSafe or OpenRouter) whether Lead should answer a buffered Slack thread follow-up, and drops the wake-up when it should not",
-  "version": "1.2.0",
+  "description": "Asks a SystemOne decision model (Jev or Clef) whether Lead should answer a buffered Slack thread follow-up, and drops the wake-up when it should not",
+  "version": "1.3.0",
   "runtime": "api",
   "assets": { "hooks": "hooks.ts" }
 }