@desplega.ai/agent-swarm 1.158.0 → 1.159.0

package/src/utils/context-window.ts

@@ -4,7 +4,10 @@
  * This module is safe for both API and worker code — it has NO database imports.
  *
  * Phase 4 + Phase 9 of the cost-tracking plan:
- *   - `getContextWindowSize` now resolves shortnames, family-versioned ids
+ *   - Model-catalog phase 4: windows come from the model catalog (no
+ *     per-model table). A new model gets the right window as soon as it
+ *     lands in `model_catalog`.
+ *   - `getContextWindowSize` resolves shortnames, family-versioned ids
  *     (`claude-sonnet-4-6`), AND dated full ids (`claude-sonnet-4-6-20251004`)
  *     by stripping the trailing date suffix. Previously the dated form fell
  *     to the 200k default — wildly wrong for sonnet/opus 4.x.
@@ -17,6 +20,9 @@
  *     deprecated; new code should use `computeContextUsedUnified`.
  */
 
+import { buildClaudeShortnameMap } from "@desplega/model-catalog";
+import { runtimeCatalogModel, runtimeCatalogSection } from "./runtime-model-catalog";
+
 /**
  * Phase 9: stamp this onto every `context_usage` event the adapter emits.
  * Callers that compute their own number for legacy reasons (e.g. pi-mono
@@ -25,43 +31,6 @@
  */
 export const CONTEXT_FORMULA = "input-cache-output" as const;
 
-const CONTEXT_WINDOW_DEFAULTS: Record<string, number> = {
-  // Anthropic Fable / Mythos tier
-  "claude-fable-5-1": 1_000_000,
-  "claude-mythos-5-1": 1_000_000,
-  "claude-opus-5-5": 1_000_000,
-  "claude-opus-5": 1_000_000,
-  "claude-fable-5": 1_000_000,
-  "claude-mythos-5": 1_000_000,
-  "claude-sonnet-5-5": 1_000_000,
-  "claude-sonnet-5": 1_000_000,
-  // Anthropic 4.x family
-  "claude-opus-4-8": 1_000_000,
-  "claude-opus-4-7": 1_000_000,
-  "claude-opus-4-6": 1_000_000,
-  "claude-opus-4-5": 1_000_000,
-  "claude-opus-4-1": 200_000,
-  "claude-opus-4-0": 200_000,
-  "claude-sonnet-4-6": 1_000_000,
-  "claude-sonnet-4-5": 1_000_000,
-  "claude-sonnet-4-0": 200_000,
-  "claude-haiku-4-5": 200_000,
-  // Anthropic 3.x family (legacy)
-  "claude-3-7-sonnet": 200_000,
-  "claude-3-5-sonnet": 200_000,
-  "claude-3-5-haiku": 200_000,
-  "claude-3-opus": 200_000,
-  "claude-3-sonnet": 200_000,
-  "claude-3-haiku": 200_000,
-  // Shortnames used by the local-CLI adapter and pi-mono OpenRouter mirror.
-  fable: 1_000_000,
-  mythos: 1_000_000,
-  opus: 1_000_000,
-  sonnet: 1_000_000,
-  haiku: 200_000,
-  default: 200_000,
-};
-
 const DEFAULT_CONTEXT_WINDOW = 200_000;
 
 /**
@@ -69,30 +38,55 @@ const DEFAULT_CONTEXT_WINDOW = 200_000;
  * resolve to the same window as the family-versioned id.
  *
  * `claude-sonnet-4-6-20251004` → `claude-sonnet-4-6`
- * `claude-haiku-4-5-20251001`  → `claude-haiku-4-5`
- *
- * Anthropic's dated full ids are always `${family}-${major}-${minor}-${YYYYMMDD}`,
- * so an 8-digit trailing date is a reliable signal.
  */
 function stripAnthropicDateSuffix(model: string): string {
   return model.replace(/-(\d{8})$/, "");
 }
 
+let shortnameMap: { section: Record<string, unknown>; map: Record<string, string> } | null = null;
+
+/** Claude CLI shortnames (`opus`, `sonnet`, ...) → newest catalog id. */
+function resolveClaudeShortname(model: string): string | undefined {
+  const section = runtimeCatalogSection("anthropic");
+  if (!shortnameMap || shortnameMap.section !== section) {
+    shortnameMap = { section, map: buildClaudeShortnameMap(section) };
+  }
+  return shortnameMap.map[model.trim().toLowerCase()];
+}
+
+function catalogContext(provider: string, model: string): number | undefined {
+  const context = runtimeCatalogModel(provider, model)?.limit?.context;
+  return typeof context === "number" && context > 0 ? context : undefined;
+}
+
+/**
+ * Context window (tokens) for a model id, read from the model catalog
+ * (`src/utils/runtime-model-catalog.ts`: live `model_catalog` + overlay,
+ * vendored models.dev snapshot offline). Accepts Anthropic ids (dated or
+ * not), Claude CLI shortnames, OpenAI/Codex ids and `provider/model` ids.
+ * Unknown models get a conservative 200k so percent math stays finite.
+ */
 export function getContextWindowSize(model: string): number {
-  // Fast path: exact match (shortname or family-versioned id).
-  if (CONTEXT_WINDOW_DEFAULTS[model] !== undefined) {
-    return CONTEXT_WINDOW_DEFAULTS[model];
+  if (!model) return DEFAULT_CONTEXT_WINDOW;
+  const slash = model.indexOf("/");
+  if (slash > 0) {
+    const scoped = catalogContext(model.slice(0, slash), model.slice(slash + 1));
+    if (scoped) return scoped;
+  }
+  for (const provider of ["anthropic", "openai"]) {
+    const exact = catalogContext(provider, model);
+    if (exact) return exact;
   }
-  // Dated full id → strip suffix and retry.
   const stripped = stripAnthropicDateSuffix(model);
-  if (stripped !== model && CONTEXT_WINDOW_DEFAULTS[stripped] !== undefined) {
-    return CONTEXT_WINDOW_DEFAULTS[stripped];
+  if (stripped !== model) {
+    const dated = catalogContext("anthropic", stripped);
+    if (dated) return dated;
+  }
+  const shortname = resolveClaudeShortname(model);
+  if (shortname) {
+    const resolved = catalogContext("anthropic", shortname);
+    if (resolved) return resolved;
   }
-  // OpenAI / GPT family — most reasoning models have 200k+; we keep this
-  // conservative and let callers override via models.dev rates if they want.
-  // Specific gpt-5.x context windows are >1M but the local-CLI adapter
-  // generally doesn't surface those; the API recompute path uses the rate
-  // table, not the window. The 200k default keeps the math safe.
   return DEFAULT_CONTEXT_WINDOW;
 }
 

package/src/utils/harness-cli-version.ts

@@ -0,0 +1,115 @@
+/**
+ * The worker's harness CLI version (`claude --version` / `codex --version`),
+ * reported on register and used to key harness_model_support rows. Worker-safe
+ * (no DB). Probed once per process; null when the CLI is missing or silent.
+ */
+import { isUnknownModelError } from "./harness-model-error";
+import { scrubSecrets } from "./secret-scrubber";
+
+const CLI_BINARY: Record<string, string> = { claude: "claude", codex: "codex" };
+const PROBE_TIMEOUT_MS = 10_000;
+const VERSION_RE = /\d+\.\d+\.\d+(?:[-+][\w.]+)?/;
+
+const probed = new Map<string, Promise<string | null>>();
+
+export function parseCliVersion(output: string): string | null {
+  return VERSION_RE.exec(output)?.[0] ?? null;
+}
+
+export function probeHarnessCliVersion(harness: string): Promise<string | null> {
+  const binary = CLI_BINARY[harness];
+  if (!binary) return Promise.resolve(null);
+  let pending = probed.get(harness);
+  if (!pending) {
+    pending = (async () => {
+      try {
+        const proc = Bun.spawn([binary, "--version"], {
+          stdin: "ignore",
+          stdout: "pipe",
+          stderr: "pipe",
+          timeout: PROBE_TIMEOUT_MS,
+          killSignal: "SIGKILL",
+        });
+        const [stdout, exitCode] = await Promise.all([
+          new Response(proc.stdout).text(),
+          proc.exited,
+        ]);
+        return exitCode === 0 ? parseCliVersion(stdout) : null;
+      } catch {
+        return null;
+      }
+    })();
+    probed.set(harness, pending);
+  }
+  return pending;
+}
+
+/** Last probed version, without waiting; null until the probe finished. */
+export async function cachedHarnessCliVersion(harness: string): Promise<string | null> {
+  return (await probed.get(harness)) ?? null;
+}
+
+const reported = new Set<string>();
+
+/**
+ * Record a model's run outcome on this worker's CLI. `ok` is sent once per
+ * model per process; `unsupported` whenever the CLI rejects the id. Other
+ * failures say nothing about support and are not sent. Never throws.
+ */
+export async function reportHarnessModelOutcome(opts: {
+  apiUrl: string;
+  apiKey?: string;
+  agentId: string;
+  harness: string;
+  model: string | undefined;
+  exitCode: number;
+  failureReason?: string;
+  fetchImpl?: typeof fetch;
+}): Promise<void> {
+  if (!opts.model || !CLI_BINARY[opts.harness]) return;
+  const cliVersion = await cachedHarnessCliVersion(opts.harness);
+  if (!cliVersion) return;
+  const status =
+    opts.exitCode === 0
+      ? "ok"
+      : isUnknownModelError(opts.failureReason, opts.model)
+        ? "unsupported"
+        : null;
+  if (!status) return;
+  const key = `${opts.harness}|${cliVersion}|${opts.model}`;
+  if (status === "ok" && reported.has(key)) return;
+  try {
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      "X-Agent-ID": opts.agentId,
+    };
+    if (opts.apiKey) headers.Authorization = `Bearer ${opts.apiKey}`;
+    const res = await (opts.fetchImpl ?? fetch)(
+      `${opts.apiUrl}/api/models-catalog/harness-support`,
+      {
+        method: "PUT",
+        headers,
+        body: JSON.stringify({
+          harness: opts.harness,
+          cliVersion,
+          modelId: opts.model,
+          status,
+          ...(status === "unsupported" && opts.failureReason
+            ? { error: scrubSecrets(opts.failureReason).slice(0, 2000) }
+            : {}),
+        }),
+      },
+    );
+    if (res.ok && status === "ok") reported.add(key);
+  } catch {
+    // Best effort: the next run reports again.
+  }
+}
+
+export function resetHarnessCliVersionForTests(seed?: Record<string, string | null>): void {
+  probed.clear();
+  reported.clear();
+  for (const [harness, version] of Object.entries(seed ?? {})) {
+    probed.set(harness, Promise.resolve(version));
+  }
+}

package/src/utils/harness-model-error.ts

@@ -0,0 +1,33 @@
+/**
+ * Recognizes a harness CLI rejecting a model id. Worker-safe (no DB).
+ *
+ * Claude Code: "There's an issue with the selected model (x). It may not exist
+ * or you may not have access to it", or the API's `not_found_error` "model: x".
+ * Codex: "The model `x` does not exist or you do not have access to it",
+ * "model is not supported", "unknown model".
+ *
+ * A model-rejection phrase can also appear in an unrelated failure ("invalid model output"),
+ * and a false positive marks the model unsupported for the whole (harness, CLI version). So
+ * when `modelId` is given, the rejection line must name that model.
+ */
+const UNKNOWN_MODEL_PATTERNS: RegExp[] = [
+  /issue with the selected model/i,
+  /model[`'" ]*[\w.:/-]*[`'" ]*(?:does not exist|not found)/i,
+  /not_found_error[^\n]*model/i,
+  /model[^\n]{0,80}is not supported/i,
+  /unsupported model/i,
+  /unknown model/i,
+  /invalid model/i,
+];
+
+export function isUnknownModelError(
+  text: string | null | undefined,
+  modelId?: string | null,
+): boolean {
+  if (!text) return false;
+  const id = modelId?.trim().toLowerCase();
+  return text.split("\n").some((line) => {
+    if (!UNKNOWN_MODEL_PATTERNS.some((re) => re.test(line))) return false;
+    return !id || line.toLowerCase().includes(id);
+  });
+}

package/src/utils/runtime-model-catalog.ts

@@ -0,0 +1,137 @@
+/**
+ * Process-wide model catalog for code that runs on BOTH sides of the
+ * API/worker boundary (provider adapters, context-window math, reasoning
+ * gating). Model-catalog phase 4: this replaces the hand-maintained per-model
+ * tables (codex allowlist/windows/pricing, claude-managed allowlist/pricing,
+ * per-model context windows, the slim reasoning snapshot).
+ *
+ * Sources, highest first:
+ *   1. the live catalog: the API server's `model_catalog` + overlay rows.
+ *      Workers pull it over HTTP (`GET /api/models-catalog`, see
+ *      `refreshRuntimeModelCatalog`); the API process sets it directly after
+ *      every catalog reload.
+ *   2. the vendored models.dev snapshot (`src/be/modelsdev-cache.json`) —
+ *      offline fallback, and the only source for ids the live catalog has
+ *      dropped (legacy models still named by old tasks and pricing rows).
+ *
+ * NO database imports (worker-safe). Every lookup is synchronous; the HTTP
+ * refresh is TTL-cached and never throws, so hot paths stay cheap.
+ */
+import modelsDevSnapshot from "../be/modelsdev-cache.json";
+
+export interface RuntimeCatalogModel {
+  id?: string;
+  name?: string;
+  cost?: { input?: number; output?: number; cache_read?: number; cache_write?: number };
+  limit?: { context?: number };
+  release_date?: string;
+  status?: string;
+  reasoning?: boolean;
+  reasoning_options?: { type?: string; values?: string[] }[];
+}
+
+export interface RuntimeCatalogProvider {
+  id?: string;
+  name?: string;
+  models?: Record<string, RuntimeCatalogModel>;
+}
+
+export type RuntimeCatalog = Record<string, RuntimeCatalogProvider | undefined>;
+
+const SNAPSHOT = modelsDevSnapshot as unknown as RuntimeCatalog;
+
+/** Default freshness window for the worker-side HTTP pull. */
+export const RUNTIME_CATALOG_TTL_MS = 10 * 60_000;
+const FETCH_TIMEOUT_MS = 5_000;
+
+let live: RuntimeCatalog | null = null;
+let liveAt = 0;
+let liveSource: "live" | "snapshot" | null = null;
+const mergedSections = new Map<string, Record<string, RuntimeCatalogModel>>();
+let inFlight: Promise<boolean> | null = null;
+
+/** Replace the live layer (API process after a reload; worker after a pull). */
+export function setRuntimeModelCatalog(
+  providers: RuntimeCatalog,
+  at: number = Date.now(),
+  source: "live" | "snapshot" = "live",
+): void {
+  live = providers;
+  liveAt = at;
+  liveSource = source;
+  mergedSections.clear();
+}
+
+export function resetRuntimeModelCatalogForTests(): void {
+  live = null;
+  liveAt = 0;
+  liveSource = null;
+  mergedSections.clear();
+  inFlight = null;
+}
+
+/** Where the current live layer came from; null = snapshot only. */
+export function runtimeModelCatalogSource(): "live" | "snapshot" | null {
+  return liveSource;
+}
+
+/** One provider section: snapshot models overlaid by the live catalog (live wins per id). */
+export function runtimeCatalogSection(provider: string): Record<string, RuntimeCatalogModel> {
+  const cached = mergedSections.get(provider);
+  if (cached) return cached;
+  const merged: Record<string, RuntimeCatalogModel> = {
+    ...(SNAPSHOT[provider]?.models ?? {}),
+    ...(live?.[provider]?.models ?? {}),
+  };
+  mergedSections.set(provider, merged);
+  return merged;
+}
+
+export function runtimeCatalogModel(
+  provider: string,
+  modelId: string,
+): RuntimeCatalogModel | undefined {
+  return runtimeCatalogSection(provider)[modelId];
+}
+
+/**
+ * Pull the live catalog from the API server. TTL-cached (`maxAgeMs`),
+ * single-flight, never throws: returns false and keeps the previous layer
+ * when the server is unreachable or answers non-2xx.
+ */
+export async function refreshRuntimeModelCatalog(opts: {
+  apiUrl: string;
+  apiKey?: string;
+  agentId?: string;
+  maxAgeMs?: number;
+  fetchImpl?: typeof fetch;
+}): Promise<boolean> {
+  const maxAge = opts.maxAgeMs ?? RUNTIME_CATALOG_TTL_MS;
+  if (live && Date.now() - liveAt < maxAge) return true;
+  if (inFlight) return inFlight;
+  const doFetch = opts.fetchImpl ?? fetch;
+  inFlight = (async () => {
+    try {
+      const headers: Record<string, string> = {};
+      if (opts.apiKey) headers.Authorization = `Bearer ${opts.apiKey}`;
+      if (opts.agentId) headers["X-Agent-ID"] = opts.agentId;
+      const res = await doFetch(`${opts.apiUrl}/api/models-catalog`, {
+        headers,
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+      });
+      if (!res.ok) return false;
+      const body = (await res.json()) as {
+        source?: "live" | "snapshot";
+        providers?: RuntimeCatalog;
+      };
+      if (!body || typeof body.providers !== "object" || body.providers === null) return false;
+      setRuntimeModelCatalog(body.providers, Date.now(), body.source ?? "live");
+      return true;
+    } catch {
+      return false;
+    } finally {
+      inFlight = null;
+    }
+  })();
+  return inFlight;
+}

package/src/workflows/approval-resolution.ts

@@ -0,0 +1,39 @@
+import type { WorkflowDefinition } from "../types";
+import type { ApprovalOutcome, ResolvedApproval } from "./executors/base";
+import type { ExecutorRegistry } from "./executors/registry";
+
+/**
+ * Step output and output port for a step whose approval request resolved.
+ *
+ * Both resume paths (the live `approval.resolved` event and the recovery sweep)
+ * go through here so they cannot disagree. A `human-in-the-loop` step gets its
+ * own output on the port named after the status. An executor that parked on the
+ * same approval machinery (`system-one-decision` with `humanReview`) shapes its
+ * own output from what it stored before it parked.
+ */
+export function shapeApprovalResolution(
+  registry: ExecutorRegistry,
+  definition: Pick<WorkflowDefinition, "nodes">,
+  nodeId: string,
+  parkedOutput: unknown,
+  approval: ResolvedApproval,
+): ApprovalOutcome {
+  const node = definition.nodes.find((candidate) => candidate.id === nodeId);
+  if (node && registry.has(node.type)) {
+    const shaped = registry.get(node.type).resolveApproval(parkedOutput, approval);
+    if (shaped) return shaped;
+  }
+  return {
+    output: {
+      requestId: approval.requestId,
+      status: approval.status,
+      responses: approval.responses,
+    },
+    nextPort:
+      approval.status === "timeout"
+        ? "timeout"
+        : approval.status === "rejected"
+          ? "rejected"
+          : "approved",
+  };
+}

package/src/workflows/definition.ts

@@ -6,6 +6,10 @@ import type {
   WorkflowPatch,
 } from "../types";
 import type { ExecutorRegistry } from "./executors/registry";
+import {
+  systemOneRetryViolations,
+  systemOneStaticShapeViolations,
+} from "./executors/system-one-decision";
 
 /** Extract all target node IDs from a node's `next` field */
 export function getNextTargets(next: string | string[] | Record<string, string>): string[] {
@@ -206,6 +210,9 @@ export function validateDefinition(
         `Node "${node.id}" human-in-the-loop config.questions must be an array or one exact {{interpolation}} token`,
       );
     }
+    // A system-one-decision node's question ids and return types are static, and it never carries
+    // an engine retry policy (it retries transient transport errors itself).
+    errors.push(...systemOneStaticShapeViolations(node), ...systemOneRetryViolations(node));
     if (node.type === "foreach") {
       validateForeachNode(node, errors);
       // A legacy `#` id may stay editable as a NORMAL node, but never as a foreach

package/src/workflows/engine.ts

@@ -28,10 +28,16 @@ import { shouldSkipCooldown } from "./cooldown";
 import { findEntryNodes, getNextTargets, getSuccessors, resolveValidationPort } from "./definition";
 import type { AsyncExecutorResult } from "./executors/base";
 import type { ExecutorRegistry } from "./executors/registry";
+import {
+  SYSTEM_ONE_DECISION_NODE_TYPE,
+  systemOneRetryViolations,
+  systemOneUnresolvedError,
+} from "./executors/system-one-decision";
 import { FOREACH_TERMINAL_STEP_STATUSES, resolveForeachParent } from "./foreach-join";
 import { getSecretInputKeys, redactSecretsForStorage, resolveInputs } from "./input";
 import { validateJsonSchema } from "./json-schema-validator";
 import { getMaxWorkflowStepsPerRun } from "./limits";
+import { findWorkflowReadinessProblems, formatReadinessRunError } from "./readiness";
 import { deepInterpolate } from "./template";
 import { runStepValidation, type ValidationRunResult } from "./validation";
 
@@ -149,6 +155,18 @@ export async function startWorkflowExecution(
     triggerType: options.triggerType ?? "manual",
   });
 
+  // An executor that cannot run (for example a system-one-decision node with no API key) fails
+  // the run here, before any node has side effects, instead of partway through.
+  const notReady = await findWorkflowReadinessProblems(workflow.definition, registry);
+  if (notReady.length > 0) {
+    await updateWorkflowRun(runId, {
+      status: "failed",
+      error: formatReadinessRunError(notReady),
+      finishedAt: new Date().toISOString(),
+    });
+    return runId;
+  }
+
   // Resolve inputs and merge into initial context
   const ctx: Record<string, unknown> = { trigger: triggerData };
   if (options.requestedByUserId) {
@@ -744,6 +762,15 @@ async function runClaimedStep(
   // 3. Get executor
   const executor = registry.get(node.type);
 
+  // 3a. A system-one-decision node retries transient transport errors itself (config.maxRetries).
+  // Engine retries are not status-aware, so a policy here would re-send rejected
+  // requests and multiply paid attempts. Fail before any request is built.
+  const systemOneRetryProblems = systemOneRetryViolations(node);
+  if (systemOneRetryProblems.length > 0) {
+    await checkpointStepFailure(runId, stepId, systemOneRetryProblems.join("; "), 0);
+    return { outcome: "failed", successors: [] };
+  }
+
   // 3b. Build local interpolation context from explicit inputs mapping
   const interpolationCtx = buildNodeInterpolationCtx(node, ctx);
 
@@ -765,6 +792,7 @@ async function runClaimedStep(
     value: interpolatedValue,
     unresolved,
     scriptBodyUnresolved,
+    strictUnresolved,
   } = interpolateNodeConfig(node, interpolationCtx);
   const interpolatedConfig = interpolatedValue as Record<string, unknown>;
   const executionCtx: Record<string, unknown> = { ...ctx, ...interpolationCtx };
@@ -775,6 +803,17 @@ async function runClaimedStep(
     return { outcome: "failed", successors: [] };
   }
 
+  // A paid, non-idempotent call must not go out with a blanked field.
+  if (strictUnresolved && strictUnresolved.length > 0) {
+    await checkpointStepFailure(
+      runId,
+      stepId,
+      systemOneUnresolvedError(node.id, strictUnresolved),
+      0,
+    );
+    return { outcome: "failed", successors: [] };
+  }
+
   if (unresolved.length > 0) {
     console.warn(
       `[workflow] Step ${node.id}: unresolved interpolation tokens: ${unresolved.join(", ")}`,
@@ -1063,7 +1102,36 @@ function buildScriptBodyCtx(
 export function interpolateNodeConfig(
   node: Pick<WorkflowNode, "type" | "config" | "inputs">,
   interpolationCtx: Record<string, unknown>,
-): { value: unknown; unresolved: string[]; scriptBodyUnresolved?: string[] } {
+): {
+  value: unknown;
+  unresolved: string[];
+  scriptBodyUnresolved?: string[];
+  /** Tokens that must resolve before dispatch; the caller fails the step when non-empty. */
+  strictUnresolved?: string[];
+} {
+  if (node.type === SYSTEM_ONE_DECISION_NODE_TYPE) {
+    // `state` and `questions` keep a whole-token reference's JSON type (an object
+    // stays an object; string interpolation would flatten it to JSON text). The
+    // resolved value is data, never re-interpolated, so a literal `{{` inside a
+    // lead's text is not read as another template. Every other field, and every
+    // unresolved token anywhere in the config, is strict: no blank reaches the API.
+    const { state, questions, ...rest } = node.config;
+    const restResult = deepInterpolate(rest, interpolationCtx);
+    const dynamic: Record<string, unknown> = {};
+    if (Object.hasOwn(node.config, "state")) dynamic.state = state;
+    if (Object.hasOwn(node.config, "questions")) dynamic.questions = questions;
+    const dynamicResult = deepInterpolate(dynamic, interpolationCtx, { preserveRawTokens: true });
+    const unresolved = [...restResult.unresolved, ...dynamicResult.unresolved];
+    return {
+      value: {
+        ...(restResult.value as Record<string, unknown>),
+        ...(dynamicResult.value as Record<string, unknown>),
+      },
+      unresolved,
+      strictUnresolved: unresolved,
+    };
+  }
+
   if (node.type === "foreach" && Object.hasOwn(node.config, "over")) {
     const { over, body, ...configWithoutOverAndBody } = node.config;
     const configResult = deepInterpolate(configWithoutOverAndBody, interpolationCtx);

package/src/workflows/executors/agent-task.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { explicitModelErrorForAgent } from "../../be/model-validation";
 import { applyPreTaskCreate } from "../../extensions/apply-task-create";
 import { workflowContextKey } from "../../tasks/context-key";
 import { TaskCreationBlockedError } from "../../tasks/errors";
@@ -30,6 +31,8 @@ export const AgentTaskConfigSchema = z.object({
   vcsRepo: z.string().min(1).optional(),
   model: z.string().min(1).optional(),
   modelTier: ModelTierSchema.optional(),
+  /** Accept a `model` the catalog does not list (a custom id). Without it an unknown id fails the node. */
+  allowCustomModel: z.boolean().optional(),
   effort: ReasoningEffortSchema.optional(),
   parentTaskId: z.string().uuid().optional(),
   requestedByUserId: z.string().optional(),
@@ -98,6 +101,12 @@ export class AgentTaskExecutor extends BaseExecutor<
     }
 
     // 3. Create the task (config is already deep-interpolated by the engine)
+    const modelError = await explicitModelErrorForAgent({
+      model: splitLegacyModelAlias({ model: config.model, modelTier: config.modelTier }).model,
+      allowCustomModel: config.allowCustomModel,
+      agentId: config.agentId,
+    });
+    if (modelError) return { status: "failed", error: modelError };
     const preCreate = await applyPreTaskCreate({
       description: config.template,
       options: {