@desplega.ai/agent-swarm 2.4.3 → 2.4.5

package/dist/{cli-s9rr4gr2.js → cli-xpa64rek.js}

@@ -5,10 +5,10 @@ import {
   completeApprovalCancellationNotificationClaim2,
   releaseApprovalCancellationNotificationClaim2,
   init_db3
-} from "./cli-vcgscaan.js";
+} from "./cli-wt0jf9hm.js";
 import {
   getSlackApp2
-} from "./cli-tkf4x6ha.js";
+} from "./cli-37j04k05.js";
 import {
   DEFAULT_MODEL,
   resolveCredential
@@ -16,7 +16,7 @@ import {
 import {
   TERMINAL_TASK_STATUSES,
   init_types
-} from "./cli-836ehxmt.js";
+} from "./cli-eww120g8.js";
 import {
   selectCredential,
   init_credentials
@@ -45,6 +45,7 @@ import {
   strictObject2,
   union2,
   discriminatedUnion,
+  tuple,
   record2,
   _enum2,
   literal2
@@ -66,7 +67,6 @@ import {
 
 // src/workflows/executors/system-one-decision.ts
 init_zod();
-init_openrouter_base_url();
 init_secret_scrubber();
 
 // src/workflows/executors/base.ts
@@ -454,7 +454,7 @@ class HumanInTheLoopExecutor extends BaseExecutor {
       }
       if (notification.channel === "slack") {
         try {
-          const { getSlackApp } = await import("./app-6sv8mhzm.js");
+          const { getSlackApp } = await import("./app-353vre8g.js");
           const slackApp = getSlackApp();
           if (!slackApp) {
             console.warn("[HITL] Slack not initialized — cannot send notification");
@@ -541,6 +541,9 @@ function formatTimeout(seconds) {
   return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
 }
 
+// src/workflows/executors/system-one-extraction.ts
+init_zod();
+
 // src/workflows/executors/system-one-providers.ts
 init_openrouter_base_url();
 
@@ -585,6 +588,35 @@ function cloudflareErrorCode(body) {
   return typeof code === "string" && ERROR_CODE_RE.test(code) ? code : undefined;
 }
 
+// src/workflows/executors/system-one-extract-wire.ts
+function extractionStateText(state) {
+  return typeof state === "string" ? state : JSON.stringify(state);
+}
+var CLAIRIC_WIRE = {
+  buildRequest: (config, model) => ({
+    ...model === undefined ? {} : { model },
+    state: extractionStateText(config.state),
+    fields: config.fields,
+    ...config.images?.length ? { images: config.images } : {},
+    ...config.referenceDate ? { reference_date: config.referenceDate } : {}
+  }),
+  toExtraction: (body) => body
+};
+var CLOUDFLARE_EXTRACT_WIRE = {
+  buildRequest: CLAIRIC_WIRE.buildRequest,
+  toExtraction(body) {
+    if (!isRecord(body))
+      wireContractError("response body must be a JSON object");
+    if (body.success !== true) {
+      const code = cloudflareErrorCode(body);
+      throw new SystemOneWireError(`Cloudflare Workers AI reported a failed run${code ? ` (${code})` : ""}. Nothing was extracted.`);
+    }
+    if (!isRecord(body.result))
+      wireContractError("Cloudflare response is missing its result");
+    return body.result;
+  }
+};
+
 // src/workflows/executors/system-one-openai-wire.ts
 function entryText(entry) {
   if (entry === undefined || entry === null)
@@ -764,27 +796,43 @@ var LAYA_KEY = "LAYA_API_KEY";
 var LAYA_URL_KEY = "LAYA_URL";
 var OPENAI_DECISIONS_KEY = "OPENAI_DECISIONS_API_KEY";
 var CLOUDFLARE_TOKEN_KEY = "CLOUDFLARE_API_TOKEN";
+var CLOUDFLARE_KEY_FALLBACK = "CLOUDFLARE_API_KEY";
 var CLOUDFLARE_ACCOUNT_KEY = "CLOUDFLARE_ACCOUNT_ID";
 var CLOUDFLARE_ACCOUNT_RE = /^[0-9a-f]{32}$/;
 async function readGlobalConfig(db, key) {
   const rows = await db.getSwarmConfigs({ scope: "global", key });
   return rows.find((row) => row.scope === "global" && row.key === key)?.value;
 }
-var SYSTEM_ONE_PROVIDERS = {
+async function readFirstGlobalConfig(db, keys) {
+  for (const keyName of keys) {
+    const value = await readGlobalConfig(db, keyName);
+    if (value && value.trim() !== "")
+      return { value, keyName };
+  }
+  return;
+}
+var CLOUDFLARE_ENDPOINT = {
+  configKey: CLOUDFLARE_ACCOUNT_KEY,
+  describe: "the 32-character id of a Cloudflare account",
+  build: (accountId, model) => {
+    const id = accountId.trim();
+    return CLOUDFLARE_ACCOUNT_RE.test(id) ? `https://api.cloudflare.com/client/v4/accounts/${id}/ai/run/@cf/cloudflare/${model}` : null;
+  }
+};
+var SYSTEM_ONE_HOSTS = {
   typesafe: {
     label: "TypeSafe",
     keyName: TYPESAFE_KEY,
-    endpoint: "https://api.typesafe.ai/v1/systemone",
-    defaultModel: "jev-latest",
-    confidenceField: "confidence",
-    readKey: ({ db }) => readGlobalConfig(db, TYPESAFE_KEY)
+    readKey: ({ db }) => readGlobalConfig(db, TYPESAFE_KEY),
+    decide: {
+      endpoint: "https://api.typesafe.ai/v1/systemone",
+      defaultModel: "jev-latest",
+      confidenceField: "confidence"
+    }
   },
   openrouter: {
     label: "OpenRouter",
     keyName: OPENROUTER_KEY,
-    endpoint: "https://openrouter.ai/api/alpha/decisions",
-    defaultModel: "~typesafe/jev-latest",
-    confidenceField: "confidence",
     deploymentProblem(env) {
       return getOpenRouterBaseUrl(env) === DEFAULT_OPENROUTER_BASE_URL ? null : 'OPENROUTER_BASE_URL points at a gateway. SystemOne provider "openrouter" calls openrouter.ai directly and is not supported through a gateway; unset OPENROUTER_BASE_URL or use provider "typesafe".';
     },
@@ -794,97 +842,153 @@ var SYSTEM_ONE_PROVIDERS = {
       } catch {
         return null;
       }
+    },
+    decide: {
+      endpoint: "https://openrouter.ai/api/alpha/decisions",
+      defaultModel: "~typesafe/jev-latest",
+      confidenceField: "confidence"
     }
   },
   laya: {
     label: "laya",
     keyName: LAYA_KEY,
-    endpoint: { configKey: LAYA_URL_KEY, path: "/v1/systemone" },
-    confidenceField: "answer_confidence",
-    readKey: ({ db }) => readGlobalConfig(db, LAYA_KEY)
+    readKey: ({ db }) => readGlobalConfig(db, LAYA_KEY),
+    decide: {
+      endpoint: { configKey: LAYA_URL_KEY, path: "/v1/systemone" },
+      confidenceField: "answer_confidence"
+    }
   },
   openai: {
     label: "OpenAI",
     keyName: OPENAI_DECISIONS_KEY,
-    endpoint: "https://api.openai.com/v1/decisions",
-    defaultModel: "gpt-6-luna",
-    confidenceField: "confidence",
-    wire: OPENAI_DECISIONS_WIRE,
-    readKey: ({ db }) => readGlobalConfig(db, OPENAI_DECISIONS_KEY)
+    readKey: ({ db }) => readGlobalConfig(db, OPENAI_DECISIONS_KEY),
+    decide: {
+      endpoint: "https://api.openai.com/v1/decisions",
+      defaultModel: "gpt-6-luna",
+      confidenceField: "confidence",
+      wire: OPENAI_DECISIONS_WIRE
+    }
   },
   cloudflare: {
     label: "Cloudflare Workers AI",
     keyName: CLOUDFLARE_TOKEN_KEY,
-    endpoint: {
-      configKey: CLOUDFLARE_ACCOUNT_KEY,
-      describe: "the 32-character id of a Cloudflare account",
-      build: (accountId, model) => {
-        const id = accountId.trim();
-        return CLOUDFLARE_ACCOUNT_RE.test(id) ? `https://api.cloudflare.com/client/v4/accounts/${id}/ai/run/@cf/cloudflare/${model}` : null;
-      }
+    fallbackKeyNames: [CLOUDFLARE_KEY_FALLBACK],
+    readKey: ({ db }) => readFirstGlobalConfig(db, [CLOUDFLARE_TOKEN_KEY, CLOUDFLARE_KEY_FALLBACK]),
+    decide: {
+      endpoint: CLOUDFLARE_ENDPOINT,
+      defaultModel: "clef",
+      allowedModels: ["clef", "clef-flash"],
+      limits: { maxQuestions: 64 },
+      confidenceField: "confidence",
+      wire: CLOUDFLARE_WIRE
     },
-    defaultModel: "clef",
-    allowedModels: ["clef", "clef-flash"],
-    limits: { maxQuestions: 64 },
-    confidenceField: "confidence",
-    wire: CLOUDFLARE_WIRE,
-    readKey: ({ db }) => readGlobalConfig(db, CLOUDFLARE_TOKEN_KEY)
+    extract: {
+      endpoint: CLOUDFLARE_ENDPOINT,
+      defaultModel: "clairic",
+      allowedModels: ["clairic"],
+      limits: { maxFields: 64, maxImages: 4 },
+      wire: CLOUDFLARE_EXTRACT_WIRE
+    }
   }
 };
-var SYSTEM_ONE_PROVIDER_IDS = Object.keys(SYSTEM_ONE_PROVIDERS);
+function hostsServing(capability) {
+  const ids = Object.keys(SYSTEM_ONE_HOSTS).filter((id) => SYSTEM_ONE_HOSTS[id][capability] !== undefined);
+  return ids;
+}
+var SYSTEM_ONE_PROVIDERS = Object.fromEntries(hostsServing("decide").map((id) => {
+  const { decide, extract: _extract, ...host } = SYSTEM_ONE_HOSTS[id];
+  return [id, { ...host, ...decide }];
+}));
+var SYSTEM_ONE_PROVIDER_IDS = hostsServing("decide");
+var SYSTEM_ONE_EXTRACT_PROVIDER_IDS = hostsServing("extract");
 var SYSTEM_ONE_DEFAULT_PROVIDER = "typesafe";
+var SYSTEM_ONE_EXTRACT_DEFAULT_PROVIDER = "cloudflare";
+var SYSTEM_ONE_DEFAULT_PROVIDER_CONFIG_KEY = "SYSTEM_ONE_DEFAULT_PROVIDER";
 function isSystemOneProviderId(value) {
-  return typeof value === "string" && Object.hasOwn(SYSTEM_ONE_PROVIDERS, value);
+  return typeof value === "string" && SYSTEM_ONE_PROVIDER_IDS.includes(value);
+}
+async function resolveSystemOneDefaultProvider(ctx) {
+  let stored;
+  try {
+    stored = await readGlobalConfig(ctx.db, SYSTEM_ONE_DEFAULT_PROVIDER_CONFIG_KEY);
+  } catch {}
+  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;
+}
+function isSystemOneExtractProviderId(value) {
+  return typeof value === "string" && SYSTEM_ONE_EXTRACT_PROVIDER_IDS.includes(value);
 }
-function systemOneProviderOf(config) {
+function systemOneProviderOf(config, defaultId = SYSTEM_ONE_DEFAULT_PROVIDER) {
   if (config.provider === undefined)
-    return SYSTEM_ONE_DEFAULT_PROVIDER;
+    return defaultId;
   return isSystemOneProviderId(config.provider) ? config.provider : undefined;
 }
+function systemOneExtractProviderOf(config) {
+  if (config.provider === undefined)
+    return SYSTEM_ONE_EXTRACT_DEFAULT_PROVIDER;
+  return isSystemOneExtractProviderId(config.provider) ? config.provider : undefined;
+}
+function serviceOf(id, capability) {
+  const service = SYSTEM_ONE_HOSTS[id][capability];
+  if (!service)
+    throw new Error(`SystemOne provider "${id}" does not serve ${capability}`);
+  return service;
+}
+var NOTHING_PRODUCED = {
+  decide: "No decision was made.",
+  extract: "Nothing was extracted."
+};
 var SET_IT = (keyName) => `Set ${keyName} as a global secret on the Secrets page (Settings > Secrets).`;
 var SET_URL = (configKey) => `Set ${configKey} as a global config value (set-config with scope global).`;
 function systemOneKeyMissingMessage(id) {
-  const { label, keyName } = SYSTEM_ONE_PROVIDERS[id];
-  return `${keyName} is not configured. SystemOne provider "${id}" needs a working ${label} API key. ${SET_IT(keyName)}`;
+  const { label, keyName, fallbackKeyNames } = SYSTEM_ONE_HOSTS[id];
+  const also = fallbackKeyNames?.length ? ` (${fallbackKeyNames.join(", ")} is read when it is unset, and is not configured either)` : "";
+  return `${keyName} is not configured${also}. SystemOne provider "${id}" needs a working ${label} API key. ${SET_IT(keyName)}`;
 }
 function systemOneKeyUnreadableMessage(id) {
-  return `Could not read ${SYSTEM_ONE_PROVIDERS[id].keyName} from swarm config`;
+  return `Could not read ${SYSTEM_ONE_HOSTS[id].keyName} from swarm config`;
 }
-function systemOneKeyMalformedMessage(id) {
-  return `${SYSTEM_ONE_PROVIDERS[id].keyName} is not a valid bearer token value. ${SET_IT(SYSTEM_ONE_PROVIDERS[id].keyName)}`;
+function systemOneKeyMalformedMessage(id, keyName) {
+  const name = keyName ?? SYSTEM_ONE_HOSTS[id].keyName;
+  return `${name} is not a valid bearer token value. ${SET_IT(name)}`;
 }
-function systemOneKeyRejectedMessage(id, status, code) {
-  const { label, keyName } = SYSTEM_ONE_PROVIDERS[id];
+function systemOneKeyRejectedMessage(id, status, code, options = {}) {
+  const { label } = SYSTEM_ONE_HOSTS[id];
+  const keyName = options.keyName ?? SYSTEM_ONE_HOSTS[id].keyName;
   const detail = code ? ` (${code})` : "";
-  return `${keyName} was rejected by ${label} (HTTP ${status}${detail}). ` + `The key is invalid, revoked, or lacks access to the model. Replace it on the Secrets page (Settings > Secrets). No decision was made.`;
+  return `${keyName} was rejected by ${label} (HTTP ${status}${detail}). ` + `The key is invalid, revoked, or lacks access to the model. Replace it on the Secrets page (Settings > Secrets). ${NOTHING_PRODUCED[options.capability ?? "decide"]}`;
 }
-function urlKeyOf(provider) {
-  return typeof provider.endpoint === "string" ? null : provider.endpoint.configKey;
+function urlKeyOf(endpoint) {
+  return typeof endpoint === "string" ? null : endpoint.configKey;
 }
 function isBuiltEndpoint(endpoint) {
   return typeof endpoint !== "string" && "build" in endpoint;
 }
-function urlDescriptionOf(provider) {
-  return isBuiltEndpoint(provider.endpoint) ? provider.endpoint.describe : `the URL of a ${provider.label} server`;
+function urlDescriptionOf(id, endpoint) {
+  return isBuiltEndpoint(endpoint) ? endpoint.describe : `the URL of a ${SYSTEM_ONE_HOSTS[id].label} server`;
 }
-function systemOneUrlMissingMessage(id) {
-  const provider = SYSTEM_ONE_PROVIDERS[id];
-  const configKey = urlKeyOf(provider) ?? "";
-  return `${configKey} is not configured. SystemOne provider "${id}" needs ${urlDescriptionOf(provider)}. ${SET_URL(configKey)}`;
+function systemOneUrlMissingMessage(id, capability = "decide") {
+  const { endpoint } = serviceOf(id, capability);
+  const configKey = urlKeyOf(endpoint) ?? "";
+  return `${configKey} is not configured. SystemOne provider "${id}" needs ${urlDescriptionOf(id, endpoint)}. ${SET_URL(configKey)}`;
 }
-function systemOneUrlUnreadableMessage(id) {
-  return `Could not read ${urlKeyOf(SYSTEM_ONE_PROVIDERS[id]) ?? ""} from swarm config`;
+function systemOneUrlUnreadableMessage(id, capability = "decide") {
+  return `Could not read ${urlKeyOf(serviceOf(id, capability).endpoint) ?? ""} from swarm config`;
 }
-function systemOneUrlInvalidMessage(id) {
-  const provider = SYSTEM_ONE_PROVIDERS[id];
-  const configKey = urlKeyOf(provider) ?? "";
-  if (isBuiltEndpoint(provider.endpoint)) {
-    return `${configKey} is not ${provider.endpoint.describe}. ${SET_URL(configKey)}`;
+function systemOneUrlInvalidMessage(id, capability = "decide") {
+  const { endpoint } = serviceOf(id, capability);
+  const configKey = urlKeyOf(endpoint) ?? "";
+  if (isBuiltEndpoint(endpoint)) {
+    return `${configKey} is not ${endpoint.describe}. ${SET_URL(configKey)}`;
   }
-  return `${configKey} is not a usable ${provider.label} server URL. It must be an https URL (http only for localhost) with no credentials, query, or fragment. ${SET_URL(configKey)}`;
+  return `${configKey} is not a usable ${SYSTEM_ONE_HOSTS[id].label} server URL. It must be an https URL (http only for localhost) with no credentials, query, or fragment. ${SET_URL(configKey)}`;
 }
-function systemOneModelProblem(id, model) {
-  const { allowedModels } = SYSTEM_ONE_PROVIDERS[id];
+function systemOneModelProblem(id, model, capability = "decide") {
+  const { allowedModels } = serviceOf(id, capability);
   if (!allowedModels || model !== undefined && allowedModels.includes(model))
     return null;
   return `SystemOne provider "${id}" serves only the models ${allowedModels.join(", ")}; set model to one of them or leave it unset.`;
@@ -918,75 +1022,879 @@ function systemOneEndpointFromBase(base, path) {
   return `${url.origin}${url.pathname.replace(/\/+$/, "")}${path}`;
 }
 async function resolveSystemOneTarget(id, ctx, overrides = {}) {
-  const provider = SYSTEM_ONE_PROVIDERS[id];
-  const deploymentProblem = provider.deploymentProblem?.(ctx.env);
+  const host = SYSTEM_ONE_HOSTS[id];
+  const capability = overrides.capability ?? "decide";
+  const service = serviceOf(id, capability);
+  const deploymentProblem = host.deploymentProblem?.(ctx.env);
   if (deploymentProblem)
-    return { ok: false, error: deploymentProblem };
+    return { ok: false, error: deploymentProblem, deploymentRefused: true };
   const errors = [];
   let endpoint;
-  if (typeof provider.endpoint === "string") {
-    endpoint = provider.endpoint;
+  if (typeof service.endpoint === "string") {
+    endpoint = service.endpoint;
   } else {
-    const { configKey } = provider.endpoint;
+    const { configKey } = service.endpoint;
     let base;
     let readable = true;
     try {
       base = await (overrides.serverUrl ? overrides.serverUrl(id) : readGlobalConfig(ctx.db, configKey));
     } catch {
       readable = false;
-      errors.push(systemOneUrlUnreadableMessage(id));
+      errors.push(systemOneUrlUnreadableMessage(id, capability));
     }
     if (readable) {
       if (!base || base.trim() === "") {
-        errors.push(systemOneUrlMissingMessage(id));
+        errors.push(systemOneUrlMissingMessage(id, capability));
       } else {
-        const resolved = isBuiltEndpoint(provider.endpoint) ? provider.endpoint.build(base, overrides.model ?? provider.defaultModel ?? "") : systemOneEndpointFromBase(base, provider.endpoint.path);
+        const resolved = isBuiltEndpoint(service.endpoint) ? service.endpoint.build(base, overrides.model ?? service.defaultModel ?? "") : systemOneEndpointFromBase(base, service.endpoint.path);
         if (resolved)
           endpoint = resolved;
         else
-          errors.push(systemOneUrlInvalidMessage(id));
+          errors.push(systemOneUrlInvalidMessage(id, capability));
       }
     }
   }
-  let apiKey;
+  let read;
   let keyProblem;
   try {
-    apiKey = await (overrides.apiKey ? overrides.apiKey(id) : provider.readKey(ctx));
+    read = await (overrides.apiKey ? overrides.apiKey(id) : host.readKey(ctx));
   } catch {
     keyProblem = systemOneKeyUnreadableMessage(id);
   }
+  const apiKey = typeof read === "string" ? read : read?.value;
+  const keyName = typeof read === "object" && read?.keyName || host.keyName;
   if (!keyProblem) {
     if (!apiKey || apiKey.trim() === "")
       keyProblem = systemOneKeyMissingMessage(id);
     else if (hasWhitespaceOrControl(apiKey))
-      keyProblem = systemOneKeyMalformedMessage(id);
+      keyProblem = systemOneKeyMalformedMessage(id, keyName);
   }
   if (keyProblem)
     errors.push(keyProblem);
   if (errors.length > 0 || !endpoint || !apiKey)
     return { ok: false, error: errors.join(" ") };
-  return { ok: true, apiKey, endpoint };
+  return { ok: true, apiKey, endpoint, keyName };
 }
 
-// src/workflows/executors/system-one-decision.ts
-var SYSTEM_ONE_DECISION_NODE_TYPE = "system-one-decision";
-var SYSTEM_ONE_ENDPOINT = SYSTEM_ONE_PROVIDERS.typesafe.endpoint;
-var SYSTEM_ONE_API_KEY_CONFIG_KEY = SYSTEM_ONE_PROVIDERS.typesafe.keyName;
+// src/workflows/executors/system-one-transport.ts
+init_openrouter_base_url();
 var SYSTEM_ONE_DEFAULT_TIMEOUT_MS = 30000;
 var SYSTEM_ONE_MIN_TIMEOUT_MS = 1000;
 var SYSTEM_ONE_MAX_TIMEOUT_MS = 300000;
 var SYSTEM_ONE_DEFAULT_MAX_RETRIES = 2;
 var SYSTEM_ONE_MAX_RETRIES_LIMIT = 3;
-var CHOICE_MIN_OPTIONS = 2;
-var CHOICE_MAX_OPTIONS = 255;
-var SCORE_MIN_LEVELS = 2;
-var SCORE_MAX_LEVELS = 10;
 var DEADLINE_MARGIN_MS = 250;
 var BACKOFF_BASE_MS = 500;
 var BACKOFF_CAP_MS = 8000;
-var DISTRIBUTION_TOLERANCE = 0.02;
 var MAX_RESPONSE_CHARS = 1048576;
 var MAX_ERROR_BODY_CHARS = 65536;
+var REQUEST_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
+var ERROR_CODE_RE2 = /^[A-Za-z0-9._:-]{1,64}$/;
+function readRequestId(headers) {
+  const value = headers.get("x-request-id") ?? headers.get("request-id") ?? headers.get("cf-ray");
+  return value && REQUEST_ID_RE.test(value) ? value : undefined;
+}
+function parseRetryAfter(value, now) {
+  if (!value)
+    return;
+  const trimmed = value.trim();
+  if (/^\d+(\.\d+)?$/.test(trimmed))
+    return Math.round(Number(trimmed) * 1000);
+  const at = Date.parse(trimmed);
+  return Number.isNaN(at) ? undefined : Math.max(0, at - now);
+}
+function readErrorCode(text) {
+  if (text.length === 0 || text.length > MAX_ERROR_BODY_CHARS)
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return;
+  }
+  if (!isRecord(parsed))
+    return;
+  const nested = isRecord(parsed.error) ? parsed.error : undefined;
+  const detail = isRecord(parsed.detail) ? parsed.detail : undefined;
+  for (const candidate of [
+    nested?.code,
+    nested?.type,
+    detail?.error_type,
+    parsed.code,
+    parsed.type
+  ]) {
+    if (typeof candidate === "string" && ERROR_CODE_RE2.test(candidate))
+      return candidate;
+  }
+  return cloudflareErrorCode(parsed);
+}
+function defaultSleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted)
+      return resolve();
+    const timer = setTimeout(done, ms);
+    function done() {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve();
+    }
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
+async function sendSystemOneRequest(request, options = {}) {
+  const { timeoutMs, maxRetries } = request;
+  const doFetch = options.fetch ?? fetch;
+  const sleep = options.sleep ?? defaultSleep;
+  const now = options.now ?? Date.now;
+  const random = options.random ?? Math.random;
+  const deadlineAt = now() + timeoutMs - DEADLINE_MARGIN_MS;
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), Math.max(0, deadlineAt - now()));
+  const timedOut = () => ({
+    ok: false,
+    error: `SystemOne request exceeded its ${timeoutMs}ms time budget`
+  });
+  try {
+    for (let attempt = 0;; attempt++) {
+      const result = await attemptOnce(doFetch, request, controller.signal, now);
+      if (result.kind === "ok") {
+        return { ok: true, text: result.text, requestId: result.requestId };
+      }
+      if (result.kind === "timeout" || controller.signal.aborted)
+        return timedOut();
+      const attempts = attempt + 1;
+      const suffix = attempts > 1 ? ` after ${attempts} attempts` : "";
+      if (!result.retryable || attempt >= maxRetries) {
+        return { ok: false, error: `${result.message}${suffix}` };
+      }
+      const backoff = Math.min(BACKOFF_CAP_MS, BACKOFF_BASE_MS * 2 ** attempt);
+      const delay = result.retryAfterMs ?? Math.round(backoff * (0.5 + random() * 0.5));
+      if (delay >= deadlineAt - now()) {
+        return {
+          ok: false,
+          error: `${result.message}${suffix}; the ${delay}ms retry delay does not fit the ${timeoutMs}ms time budget`
+        };
+      }
+      await sleep(delay, controller.signal);
+      if (controller.signal.aborted)
+        return timedOut();
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function attemptOnce(doFetch, request, signal, now) {
+  const { endpoint, apiKey, body } = request;
+  let res;
+  try {
+    res = await doFetch(endpoint, {
+      method: "POST",
+      headers: {
+        ...getOpenRouterAttributionHeaders(endpoint, request.env),
+        "content-type": "application/json",
+        accept: "application/json",
+        authorization: `Bearer ${apiKey}`
+      },
+      body,
+      redirect: "manual",
+      signal
+    });
+  } catch (err) {
+    if (signal.aborted)
+      return { kind: "timeout" };
+    const code = err?.code;
+    const detail = typeof code === "string" && /^[A-Z0-9_]{3,40}$/.test(code) ? ` (${code})` : "";
+    return {
+      kind: "fail",
+      message: `SystemOne request failed: network error${detail}`,
+      retryable: true
+    };
+  }
+  const requestId = readRequestId(res.headers);
+  const withId = (message) => requestId ? `${message} [request ${requestId}]` : message;
+  if (res.status >= 200 && res.status < 300) {
+    let text;
+    try {
+      text = await res.text();
+    } catch {
+      if (signal.aborted)
+        return { kind: "timeout" };
+      return {
+        kind: "fail",
+        message: withId("SystemOne response body could not be read"),
+        retryable: true
+      };
+    }
+    if (text.length > MAX_RESPONSE_CHARS) {
+      return {
+        kind: "fail",
+        message: withId("SystemOne response exceeded the size limit"),
+        retryable: false
+      };
+    }
+    return { kind: "ok", text, requestId };
+  }
+  if (res.status >= 300 && res.status < 400) {
+    return {
+      kind: "fail",
+      message: withId(`SystemOne request was redirected (HTTP ${res.status}); redirects are refused`),
+      retryable: false
+    };
+  }
+  let errorText = "";
+  try {
+    errorText = await res.text();
+  } catch {
+    if (signal.aborted)
+      return { kind: "timeout" };
+  }
+  const code = readErrorCode(errorText);
+  if (res.status === 401 || res.status === 403) {
+    return {
+      kind: "fail",
+      message: withId(systemOneKeyRejectedMessage(request.providerId, res.status, code, {
+        keyName: request.keyName,
+        capability: request.capability
+      })),
+      retryable: false
+    };
+  }
+  const detail = code ? ` (${code})` : "";
+  const retryable = res.status === 408 || res.status === 429 || res.status >= 500;
+  return {
+    kind: "fail",
+    message: withId(`SystemOne API returned HTTP ${res.status}${detail}`),
+    retryable,
+    retryAfterMs: retryable ? parseRetryAfter(res.headers.get("retry-after"), now()) : undefined
+  };
+}
+
+// src/workflows/executors/system-one-extraction.ts
+var SYSTEM_ONE_EXTRACTION_NODE_TYPE = "system-one-extraction";
+var EXTRACTION_FIELD_TYPES = [
+  "text",
+  "number",
+  "date",
+  "time",
+  "datetime",
+  "duration",
+  "list",
+  "estimate",
+  "forecast"
+];
+var DURATION_UNITS = ["seconds", "minutes", "hours", "days", "weeks", "months", "years"];
+var LIST_ITEMS = ["text", "number", "date"];
+var FORECAST_INTERVALS = [
+  "step",
+  "minute",
+  "hour",
+  "day",
+  "week",
+  "month",
+  "quarter",
+  "year"
+];
+var FIELD_ID_RE = /^[A-Za-z_][A-Za-z0-9_-]{0,63}$/;
+var FIELD_ID_MESSAGE = "field ids must start with a letter or underscore, use only letters, digits, _ or -, and be at most 64 characters";
+var RESERVED_FIELD_IDS = new Set([...Object.getOwnPropertyNames(Object.prototype), "prototype"]);
+var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var MAX_IMAGES = 4;
+var MAX_IMAGE_BYTES = 4 * 1024 * 1024;
+var MAX_IMAGES_TOTAL_BYTES = 8 * 1024 * 1024;
+var IMAGE_TYPES = ["image/png", "image/jpeg", "image/webp"];
+var DATA_URL_RE = /^data:(image\/(?:png|jpeg|webp));base64,([A-Za-z0-9+/=\s]+)$/i;
+var Instructions = string2().trim().min(1, "instructions must not be blank");
+var NullThreshold = number2().gt(0, "null_threshold must be above 0").max(1, "null_threshold must be at most 1");
+var Decimals = number2().int().min(0).max(6);
+var Unit = string2().trim().min(1, "unit must not be blank");
+var Scale = _enum2(["linear", "log"]);
+var Bound = union2([
+  number2(),
+  string2().regex(ISO_DATE_RE, "must be a number or an ISO date (YYYY-MM-DD)")
+]);
+var plain = { instructions: Instructions.optional(), null_threshold: NullThreshold.optional() };
+var TextField = strictObject2({ type: literal2("text"), ...plain });
+var NumberField = strictObject2({
+  type: literal2("number"),
+  ...plain,
+  unit: Unit.optional(),
+  integer: boolean().optional(),
+  decimals: Decimals.optional()
+});
+var DateField = strictObject2({ type: literal2("date"), ...plain });
+var TimeField = strictObject2({ type: literal2("time"), ...plain });
+var DatetimeField = strictObject2({ type: literal2("datetime"), ...plain });
+var DurationField = strictObject2({
+  type: literal2("duration"),
+  ...plain,
+  unit: _enum2(DURATION_UNITS).optional(),
+  integer: boolean().optional(),
+  decimals: Decimals.optional()
+});
+var ListField = strictObject2({
+  type: literal2("list"),
+  instructions: Instructions.optional(),
+  items: _enum2(LIST_ITEMS),
+  decimals: Decimals.optional()
+});
+var EstimateField = strictObject2({
+  type: literal2("estimate"),
+  instructions: Instructions.optional(),
+  unit: Unit.optional(),
+  min: Bound,
+  max: Bound,
+  step: union2([number2().positive(), _enum2(["month", "year"])]).optional(),
+  scale: Scale.optional()
+});
+var ForecastField = strictObject2({
+  type: literal2("forecast"),
+  instructions: Instructions.optional(),
+  unit: Unit.optional(),
+  min: number2(),
+  max: number2(),
+  horizon: number2().int().min(1).max(64).optional(),
+  interval: _enum2(FORECAST_INTERVALS).optional(),
+  scale: Scale.optional()
+});
+var SystemOneExtractionFieldSchema = discriminatedUnion("type", [
+  TextField,
+  NumberField,
+  DateField,
+  TimeField,
+  DatetimeField,
+  DurationField,
+  ListField,
+  EstimateField,
+  ForecastField
+]).superRefine((field, ctx) => {
+  if ("integer" in field && field.integer && field.decimals !== undefined && field.decimals > 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["decimals"],
+      message: "an integer field cannot also set decimals above 0"
+    });
+  }
+  if (field.type === "list" && field.decimals !== undefined && field.items !== "number") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["decimals"],
+      message: 'decimals applies only to a list of items "number"'
+    });
+  }
+  if (field.type === "estimate" || field.type === "forecast") {
+    const { min, max } = field;
+    if (typeof min !== typeof max) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["max"],
+        message: "min and max must both be numbers or both be ISO dates"
+      });
+    } else if (min >= max) {
+      ctx.addIssue({ code: "custom", path: ["max"], message: "max must be greater than min" });
+    }
+    if (field.scale === "log" && typeof min === "number" && min <= 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["min"],
+        message: 'a "log" scale needs min above 0'
+      });
+    }
+    if (field.type === "estimate" && typeof field.step === "string" && typeof field.min === "number") {
+      ctx.addIssue({
+        code: "custom",
+        path: ["step"],
+        message: `step "${field.step}" applies only to a date estimate (ISO date min and max)`
+      });
+    }
+  }
+});
+var ImageSchema = union2([
+  string2().regex(DATA_URL_RE, "an image must be a base64 data: URL of a PNG, JPEG or WebP"),
+  strictObject2({ content_type: _enum2(IMAGE_TYPES), base64: string2().min(1) })
+]);
+function imageBytes(image) {
+  const base64 = (typeof image === "string" ? DATA_URL_RE.exec(image)?.[2] ?? "" : image.base64).replace(/\s+/g, "");
+  const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+  return Math.floor(base64.length * 3 / 4) - padding;
+}
+var SystemOneExtractionConfigSchema = strictObject2({
+  provider: _enum2(SYSTEM_ONE_EXTRACT_PROVIDER_IDS).default(SYSTEM_ONE_EXTRACT_DEFAULT_PROVIDER),
+  model: string2().min(1).optional(),
+  state: union2([string2(), array2(unknown()), record2(string2(), unknown())]).default(""),
+  images: array2(ImageSchema).max(MAX_IMAGES).optional(),
+  referenceDate: string2().regex(ISO_DATE_RE, "referenceDate must be an ISO date (YYYY-MM-DD)").optional(),
+  timeoutMs: number2().int().min(SYSTEM_ONE_MIN_TIMEOUT_MS).max(SYSTEM_ONE_MAX_TIMEOUT_MS).default(SYSTEM_ONE_DEFAULT_TIMEOUT_MS),
+  maxRetries: number2().int().min(0).max(SYSTEM_ONE_MAX_RETRIES_LIMIT).default(SYSTEM_ONE_DEFAULT_MAX_RETRIES),
+  fields: record2(string2().regex(FIELD_ID_RE, FIELD_ID_MESSAGE), SystemOneExtractionFieldSchema)
+}).superRefine((config, ctx) => {
+  const fieldIds = Object.keys(config.fields);
+  if (fieldIds.length === 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["fields"],
+      message: "system-one-extraction needs at least one field"
+    });
+  }
+  for (const id of fieldIds) {
+    if (RESERVED_FIELD_IDS.has(id)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["fields", id],
+        message: `"${id}" is reserved and cannot be a field id`
+      });
+    }
+  }
+  const stateText = typeof config.state === "string" ? config.state : "nonempty";
+  if (stateText.trim() === "" && !config.images?.length) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["state"],
+      message: "state must not be empty unless images are sent"
+    });
+  }
+  const images = config.images ?? [];
+  let total = 0;
+  images.forEach((image, index) => {
+    const bytes = imageBytes(image);
+    total += bytes;
+    if (bytes > MAX_IMAGE_BYTES) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["images", index],
+        message: "an image must be at most 4 MiB decoded"
+      });
+    }
+  });
+  if (total > MAX_IMAGES_TOTAL_BYTES) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["images"],
+      message: "images must total at most 8 MiB decoded"
+    });
+  }
+  const host = SYSTEM_ONE_HOSTS[config.provider];
+  const service = host.extract;
+  const modelProblem = systemOneModelProblem(config.provider, config.model ?? service?.defaultModel, "extract");
+  if (modelProblem)
+    ctx.addIssue({ code: "custom", path: ["model"], message: modelProblem });
+  const maxFields = service?.limits?.maxFields;
+  if (maxFields !== undefined && fieldIds.length > maxFields) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["fields"],
+      message: `SystemOne provider "${config.provider}" takes at most ${maxFields} fields per node; this node has ${fieldIds.length}.`
+    });
+  }
+  const maxImages = service?.limits?.maxImages;
+  if (maxImages !== undefined && images.length > maxImages) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["images"],
+      message: `SystemOne provider "${config.provider}" takes at most ${maxImages} images per node.`
+    });
+  }
+});
+var UnitInterval = number2().min(0).max(1);
+var Span = tuple([number2().int().min(0), number2().int().min(0)]);
+var Point = union2([number2(), string2()]);
+var SystemOneExtractionAnswerSchema = strictObject2({
+  type: _enum2(EXTRACTION_FIELD_TYPES),
+  value: unknown(),
+  guess: unknown().optional(),
+  p_null: UnitInterval.optional(),
+  confidence: UnitInterval.optional(),
+  span: Span.optional(),
+  spans: array2(Span).optional(),
+  unit: string2().optional(),
+  mean: union2([Point, array2(Point)]).optional(),
+  median: union2([Point, array2(Point)]).optional(),
+  p10: union2([Point, array2(Point)]).optional(),
+  p90: union2([Point, array2(Point)]).optional(),
+  p_below: UnitInterval.optional(),
+  p_above: UnitInterval.optional()
+});
+var SystemOneExtractionOutputSchema = object2({
+  model: string2().min(1),
+  answers: record2(string2(), SystemOneExtractionAnswerSchema),
+  usage: object2({
+    input_tokens: number2().int().min(0),
+    output_tokens: number2().int().min(0)
+  }),
+  truncated: boolean().optional(),
+  requestId: string2().optional()
+});
+function hasToken(value) {
+  if (typeof value === "string")
+    return value.includes("{{") && value.includes("}}");
+  if (Array.isArray(value))
+    return value.some(hasToken);
+  if (isRecord(value))
+    return Object.values(value).some(hasToken);
+  return false;
+}
+function templatedFieldViolations(nodeId, fields) {
+  const violations = [];
+  for (const [id, spec] of Object.entries(fields)) {
+    if (!hasToken(spec))
+      continue;
+    const at = `Node "${nodeId}" (system-one-extraction) config.fields.${id}`;
+    if (!FIELD_ID_RE.test(id)) {
+      violations.push(`${at}: ${FIELD_ID_MESSAGE}`);
+    } else if (RESERVED_FIELD_IDS.has(id)) {
+      violations.push(`${at}: "${id}" is reserved and cannot be a field id`);
+    }
+    if (!isRecord(spec)) {
+      violations.push(`${at} must be an object: field types and options are static, only instructions may use {{tokens}}`);
+      continue;
+    }
+    const tokened = Object.keys(spec).filter((key) => key !== "instructions" && hasToken(spec[key]));
+    for (const key of tokened) {
+      violations.push(`${at}.${key} must be a literal: only instructions may use {{tokens}}`);
+    }
+    if (tokened.length > 0)
+      continue;
+    if (typeof spec.instructions !== "string") {
+      violations.push(`${at}.instructions must be a string to use {{tokens}}`);
+      continue;
+    }
+    const parsed = SystemOneExtractionFieldSchema.safeParse({ ...spec, instructions: "x" });
+    if (parsed.success)
+      continue;
+    for (const issue of parsed.error.issues) {
+      const path = issue.path.length > 0 ? `${at}.${issue.path.map(String).join(".")}` : at;
+      violations.push(`${path}: ${issue.message}`);
+    }
+  }
+  return violations;
+}
+var STAND_IN_IMAGE = "data:image/png;base64,AAAA";
+function standInConfig(config) {
+  const known = new Set(Object.keys(SystemOneExtractionConfigSchema.shape));
+  const out = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (!hasToken(value) || key === "fields" || !known.has(key)) {
+      out[key] = value;
+    } else if (key === "state") {
+      out.state = typeof value === "string" ? "x" : value;
+    } else if (key === "images" && Array.isArray(value)) {
+      out.images = value.map((image) => hasToken(image) ? STAND_IN_IMAGE : image);
+    }
+  }
+  if (isRecord(config.fields)) {
+    out.fields = Object.fromEntries(Object.entries(config.fields).map(([id, spec]) => [
+      id,
+      isRecord(spec) && hasToken(spec) ? { ...spec, instructions: "x" } : spec
+    ]));
+  }
+  return out;
+}
+function templatedConfigViolations(nodeId, config) {
+  if (!hasToken(config))
+    return [];
+  const parsed = SystemOneExtractionConfigSchema.safeParse(standInConfig(config));
+  if (parsed.success)
+    return [];
+  const violations = [];
+  for (const issue of parsed.error.issues) {
+    let value = config;
+    for (const segment of issue.path) {
+      value = isRecord(value) || Array.isArray(value) ? value[segment] : undefined;
+    }
+    if (!hasToken(value) || typeof value === "string")
+      continue;
+    const path = ["config", ...issue.path.map(String)].join(".");
+    violations.push(`Node "${nodeId}" (system-one-extraction) ${path}: ${issue.message}`);
+  }
+  return violations;
+}
+function systemOneExtractionStaticShapeViolations(node) {
+  if (node.type !== SYSTEM_ONE_EXTRACTION_NODE_TYPE)
+    return [];
+  const violations = [];
+  const fields = node.config.fields;
+  if (fields !== undefined && (typeof fields !== "object" || fields === null || Array.isArray(fields))) {
+    violations.push(`Node "${node.id}" (system-one-extraction) config.fields must be an object: field ids and types are static, only state, images, and instructions may use {{tokens}}`);
+  } else if (fields !== undefined) {
+    violations.push(...templatedFieldViolations(node.id, fields));
+  }
+  const provider = node.config.provider;
+  if (typeof provider === "string" && provider.includes("{{")) {
+    violations.push(`Node "${node.id}" (system-one-extraction) config.provider must be a literal (${SYSTEM_ONE_EXTRACT_PROVIDER_IDS.join(", ")}), not a {{token}}: the provider decides which credential is checked before the run starts`);
+  }
+  if (violations.length === 0) {
+    violations.push(...templatedConfigViolations(node.id, node.config));
+  }
+  return violations;
+}
+
+class ExtractionContractError extends Error {
+}
+function fail(message) {
+  throw new ExtractionContractError(message);
+}
+function unitOrUndefined(value, what) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+    fail(`${what} must be a finite number between 0 and 1`);
+  }
+  return value;
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isSpan(value) {
+  return Array.isArray(value) && value.length === 2 && value.every((n) => Number.isInteger(n) && n >= 0) && value[0] <= value[1];
+}
+function isPoint(value, dates) {
+  return dates ? typeof value === "string" : isFiniteNumber(value);
+}
+function checkScalar(at, field, value) {
+  if (value === null)
+    return;
+  switch (field.type) {
+    case "text":
+    case "date":
+    case "time":
+    case "datetime":
+      if (typeof value !== "string")
+        fail(`${at}.value must be a string or null`);
+      return;
+    case "number":
+    case "duration":
+      if (!isFiniteNumber(value))
+        fail(`${at}.value must be a finite number or null`);
+      if (field.integer && !Number.isInteger(value))
+        fail(`${at}.value must be an integer`);
+      return;
+    default:
+      return;
+  }
+}
+function validateAnswer(id, field, raw) {
+  const at = `answer "${id}"`;
+  if (!isRecord(raw))
+    fail(`${at} must be an object`);
+  if (raw.type !== field.type) {
+    fail(`${at} has type ${JSON.stringify(raw.type)} but the field declares "${field.type}"`);
+  }
+  if (!Object.hasOwn(raw, "value"))
+    fail(`${at} is missing its value`);
+  const answer = { type: field.type, value: raw.value };
+  switch (field.type) {
+    case "list": {
+      if (!Array.isArray(raw.value))
+        fail(`${at}.value must be a list`);
+      const ok = raw.value.every((item) => field.items === "number" ? isFiniteNumber(item) : typeof item === "string");
+      if (!ok)
+        fail(`${at}.value items must all be ${field.items === "number" ? "numbers" : "strings"}`);
+      if (raw.spans !== undefined) {
+        if (!Array.isArray(raw.spans) || !raw.spans.every(isSpan)) {
+          fail(`${at}.spans must be a list of [start, end] offsets`);
+        }
+        answer.spans = raw.spans;
+      }
+      break;
+    }
+    case "estimate": {
+      const dates = typeof field.min === "string";
+      if (raw.value !== null && !isPoint(raw.value, dates)) {
+        fail(`${at}.value must be ${dates ? "an ISO date" : "a finite number"} or null`);
+      }
+      for (const key of ["median", "p10", "p90"]) {
+        if (!isPoint(raw[key], dates))
+          fail(`${at}.${key} must be ${dates ? "an ISO date" : "a finite number"}`);
+        answer[key] = raw[key];
+      }
+      if (raw.mean !== undefined && isPoint(raw.mean, dates))
+        answer.mean = raw.mean;
+      break;
+    }
+    case "forecast": {
+      const steps = (value) => Array.isArray(value) && value.every(isFiniteNumber);
+      if (!steps(raw.value))
+        fail(`${at}.value must be a list of numbers, one per step`);
+      const length = raw.value.length;
+      if (field.horizon !== undefined && length !== field.horizon) {
+        fail(`${at}.value must have ${field.horizon} step(s), got ${length}`);
+      }
+      for (const key of ["median", "p10", "p90"]) {
+        if (!steps(raw[key]) || raw[key].length !== length) {
+          fail(`${at}.${key} must be a list of ${length} number(s)`);
+        }
+        answer[key] = raw[key];
+      }
+      break;
+    }
+    default:
+      checkScalar(at, field, raw.value);
+      if (raw.span !== undefined) {
+        if (!isSpan(raw.span))
+          fail(`${at}.span must be [start, end] offsets`);
+        answer.span = raw.span;
+      }
+      if (raw.guess !== undefined && raw.guess !== null) {
+        checkScalar(`${at}.guess`, field, raw.guess);
+        answer.guess = raw.guess;
+      }
+  }
+  const pNull = unitOrUndefined(raw.p_null, `${at}.p_null`);
+  if (pNull !== undefined)
+    answer.p_null = pNull;
+  const confidence = unitOrUndefined(raw.confidence, `${at}.confidence`);
+  if (confidence !== undefined)
+    answer.confidence = confidence;
+  if (field.type === "estimate") {
+    const below = unitOrUndefined(raw.p_below, `${at}.p_below`);
+    const above = unitOrUndefined(raw.p_above, `${at}.p_above`);
+    if (below !== undefined)
+      answer.p_below = below;
+    if (above !== undefined)
+      answer.p_above = above;
+  }
+  if (typeof raw.unit === "string" && raw.unit !== "")
+    answer.unit = raw.unit;
+  return answer;
+}
+function validateSystemOneExtraction(fields, body, requestId) {
+  if (!isRecord(body))
+    fail("response body must be a JSON object");
+  if (typeof body.model !== "string" || body.model === "") {
+    fail("response is missing the model that produced the answers");
+  }
+  if (!isRecord(body.answers))
+    fail("response is missing the answers object");
+  const usage = object2({ input_tokens: number2().int().min(0), output_tokens: number2().int().min(0) }).safeParse(body.usage);
+  if (!usage.success) {
+    fail("response usage must report non-negative integer input_tokens and output_tokens");
+  }
+  const declared = Object.keys(fields);
+  if (declared.length === 0)
+    fail("a system-one-extraction call needs at least one field");
+  const unexpected = Object.keys(body.answers).filter((id) => !Object.hasOwn(fields, id));
+  if (unexpected.length > 0) {
+    fail(`response contains ${unexpected.length} answer(s) for undeclared fields`);
+  }
+  const answers = {};
+  for (const id of declared) {
+    if (!Object.hasOwn(body.answers, id))
+      fail(`response is missing the answer for field "${id}"`);
+    const field = fields[id];
+    if (!field)
+      fail(`field "${id}" is not defined`);
+    answers[id] = validateAnswer(id, field, body.answers[id]);
+  }
+  return {
+    model: body.model,
+    answers,
+    usage: usage.data,
+    ...typeof body.truncated === "boolean" ? { truncated: body.truncated } : {},
+    ...requestId ? { requestId } : {}
+  };
+}
+
+class SystemOneExtractionExecutor extends BaseExecutor {
+  options;
+  type = SYSTEM_ONE_EXTRACTION_NODE_TYPE;
+  mode = "instant";
+  configSchema = SystemOneExtractionConfigSchema;
+  outputSchema = SystemOneExtractionOutputSchema;
+  constructor(deps, options = {}) {
+    super(deps);
+    this.options = options;
+  }
+  providerContext() {
+    return { db: this.deps.db, env: this.options.env ?? process.env };
+  }
+  resolveTarget(id, model) {
+    const { getApiKey, getServerUrl } = this.options;
+    return resolveSystemOneTarget(id, this.providerContext(), {
+      apiKey: getApiKey ? () => getApiKey(id) : undefined,
+      serverUrl: getServerUrl ? () => getServerUrl(id) : undefined,
+      model,
+      capability: "extract"
+    });
+  }
+  async checkReadiness(nodes) {
+    const nodeIdsByProvider = new Map;
+    for (const node of nodes) {
+      const id = systemOneExtractProviderOf(node.config);
+      if (id)
+        nodeIdsByProvider.set(id, [...nodeIdsByProvider.get(id) ?? [], node.id]);
+    }
+    const problems = [];
+    for (const [id, nodeIds] of nodeIdsByProvider) {
+      const target = await this.resolveTarget(id);
+      if (!target.ok)
+        problems.push({ nodeIds, message: target.error });
+    }
+    return problems;
+  }
+  async execute(config, _context, _meta) {
+    const extracted = await this.extract(config);
+    return extracted.ok ? { status: "success", output: extracted.output } : { status: "failed", error: extracted.error };
+  }
+  async extract(config) {
+    const providerId = config.provider;
+    const service = SYSTEM_ONE_HOSTS[providerId].extract;
+    if (!service) {
+      return { ok: false, error: `SystemOne provider "${providerId}" does not serve extraction` };
+    }
+    const model = config.model ?? service.defaultModel;
+    const modelProblem = systemOneModelProblem(providerId, model, "extract");
+    if (modelProblem)
+      return { ok: false, error: modelProblem };
+    const target = await this.resolveTarget(providerId, model);
+    if (!target.ok)
+      return { ok: false, error: target.error };
+    const { apiKey, endpoint, keyName } = target;
+    const body = JSON.stringify(service.wire.buildRequest(config, model));
+    const scrub = (message) => message.split(apiKey).join("[REDACTED]");
+    const sent = await sendSystemOneRequest({
+      providerId,
+      capability: "extract",
+      endpoint,
+      apiKey,
+      keyName,
+      body,
+      timeoutMs: config.timeoutMs,
+      maxRetries: config.maxRetries,
+      env: this.providerContext().env
+    }, this.options);
+    if (!sent.ok)
+      return { ok: false, error: scrub(sent.error) };
+    let parsed;
+    try {
+      parsed = JSON.parse(sent.text);
+    } catch {
+      return { ok: false, error: "SystemOne response was not valid JSON" };
+    }
+    try {
+      return {
+        ok: true,
+        output: validateSystemOneExtraction(config.fields, service.wire.toExtraction(parsed), sent.requestId)
+      };
+    } catch (err) {
+      const withId = (message) => sent.requestId ? `${message} [request ${sent.requestId}]` : message;
+      if (err instanceof SystemOneWireError)
+        return { ok: false, error: scrub(withId(err.message)) };
+      if (err instanceof ExtractionContractError) {
+        return { ok: false, error: scrub(withId(`${VALIDATION_PREFIX}${err.message}`)) };
+      }
+      throw err;
+    }
+  }
+}
+
+// src/workflows/executors/system-one-decision.ts
+var SYSTEM_ONE_DECISION_NODE_TYPE = "system-one-decision";
+var SYSTEM_ONE_ENDPOINT = SYSTEM_ONE_PROVIDERS.typesafe.endpoint;
+var SYSTEM_ONE_API_KEY_CONFIG_KEY = SYSTEM_ONE_PROVIDERS.typesafe.keyName;
+var CHOICE_MIN_OPTIONS = 2;
+var CHOICE_MAX_OPTIONS = 255;
+var SCORE_MIN_LEVELS = 2;
+var SCORE_MAX_LEVELS = 10;
+var DISTRIBUTION_TOLERANCE = 0.02;
 var REVIEW_PORTS = ["approved", "rejected", "timeout"];
 var ENGINE_RETRY_DEFAULT = 3;
 var SystemOneEntrySchema = union2([
@@ -1028,7 +1936,7 @@ var SystemOneQuestionSchema = discriminatedUnion("type", [
   ChoiceQuestionSchema,
   ScoreQuestionSchema
 ]);
-var Unit = number2().min(0).max(1);
+var Unit2 = number2().min(0).max(1);
 var QUESTION_ID_RE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
 var RESERVED_QUESTION_IDS = new Set([
   ...Object.getOwnPropertyNames(Object.prototype),
@@ -1036,14 +1944,14 @@ var RESERVED_QUESTION_IDS = new Set([
 ]);
 var SystemOnePrimitiveTypeSchema = _enum2(["noul", "choice", "score"]);
 var HumanReviewSchema = strictObject2({
-  band: strictObject2({ min: Unit, max: Unit }).refine((band) => band.min <= band.max, { message: "band.min must not exceed band.max" }),
+  band: strictObject2({ min: Unit2, max: Unit2 }).refine((band) => band.min <= band.max, { message: "band.min must not exceed band.max" }),
   approvers: ApproverConfigSchema,
   title: string2().min(1).optional(),
   timeout: HITLTimeoutSchema.optional(),
   notifications: array2(NotificationConfigSchema).optional()
 });
 var SystemOneDecisionConfigSchema = strictObject2({
-  provider: _enum2(SYSTEM_ONE_PROVIDER_IDS).default(SYSTEM_ONE_DEFAULT_PROVIDER),
+  provider: _enum2(SYSTEM_ONE_PROVIDER_IDS).optional(),
   model: string2().min(1).optional(),
   state: SystemOneStateSchema,
   timeoutMs: number2().int().min(SYSTEM_ONE_MIN_TIMEOUT_MS).max(SYSTEM_ONE_MAX_TIMEOUT_MS).default(SYSTEM_ONE_DEFAULT_TIMEOUT_MS),
@@ -1092,6 +2000,8 @@ var SystemOneDecisionConfigSchema = strictObject2({
       });
     }
   }
+  if (config.provider === undefined)
+    return;
   const modelProblem = systemOneModelProblem(config.provider, config.model ?? SYSTEM_ONE_PROVIDERS[config.provider].defaultModel);
   if (modelProblem)
     ctx.addIssue({ code: "custom", path: ["model"], message: modelProblem });
@@ -1099,19 +2009,19 @@ var SystemOneDecisionConfigSchema = strictObject2({
   if (limitProblem)
     ctx.addIssue({ code: "custom", path: ["questions"], message: limitProblem });
 });
-var NoulAnswerSchema = strictObject2({ type: literal2("noul"), noul: Unit });
+var NoulAnswerSchema = strictObject2({ type: literal2("noul"), noul: Unit2 });
 var ChoiceAnswerSchema = strictObject2({
   type: literal2("choice"),
   choice: string2(),
-  probabilities: record2(string2(), Unit),
-  confidence: Unit
+  probabilities: record2(string2(), Unit2),
+  confidence: Unit2
 });
 var ScoreAnswerSchema = strictObject2({
   type: literal2("score"),
   score: number2(),
   legend: record2(string2(), SystemOneEntrySchema),
-  probabilities: record2(string2(), Unit),
-  confidence: Unit
+  probabilities: record2(string2(), Unit2),
+  confidence: Unit2
 });
 var SystemOneAnswerSchema = discriminatedUnion("type", [
   NoulAnswerSchema,
@@ -1119,7 +2029,7 @@ var SystemOneAnswerSchema = discriminatedUnion("type", [
   ScoreAnswerSchema
 ]);
 var ReviewQuestionSchema = strictObject2({
-  confidence: Unit,
+  confidence: Unit2,
   inBand: boolean(),
   decidedBy: _enum2(["model", "human"]),
   modelAnswer: union2([string2(), number2()]).optional()
@@ -1141,16 +2051,23 @@ var SystemOneDecisionOutputSchema = object2({
   routing: strictObject2({ model: string2().min(1) }).optional(),
   review: ReviewSchema.optional()
 });
+var SYSTEM_ONE_NODE_LABELS = {
+  [SYSTEM_ONE_DECISION_NODE_TYPE]: "SystemOne Decision",
+  [SYSTEM_ONE_EXTRACTION_NODE_TYPE]: "SystemOne Extraction"
+};
+function isSystemOneNodeType(type) {
+  return Object.hasOwn(SYSTEM_ONE_NODE_LABELS, type);
+}
 function systemOneRetryViolations(node) {
-  if (node.type !== SYSTEM_ONE_DECISION_NODE_TYPE)
+  if (!isSystemOneNodeType(node.type))
     return [];
   const violations = [];
   const attempts = (retry) => retry ? retry.maxRetries ?? ENGINE_RETRY_DEFAULT : 0;
   if (attempts(node.retry) > 0) {
-    violations.push(`Node "${node.id}" (system-one-decision) must not set retry.maxRetries > 0: the system-one-decision executor retries transient transport errors itself (config.maxRetries), and engine retries would re-send rejected requests`);
+    violations.push(`Node "${node.id}" (${node.type}) must not set retry.maxRetries > 0: the ${node.type} executor retries transient transport errors itself (config.maxRetries), and engine retries would re-send rejected requests`);
   }
   if (attempts(node.validation?.retry) > 0) {
-    violations.push(`Node "${node.id}" (system-one-decision) must not set validation.retry.maxRetries > 0: a validation-driven retry would send another paid request`);
+    violations.push(`Node "${node.id}" (${node.type}) must not set validation.retry.maxRetries > 0: a validation-driven retry would send another paid request`);
   }
   return violations;
 }
@@ -1184,14 +2101,15 @@ function systemOneStaticShapeViolations(node) {
   }
   return violations;
 }
-function systemOneUnresolvedError(nodeId, tokens) {
+function systemOneUnresolvedError(nodeId, tokens, nodeType = SYSTEM_ONE_DECISION_NODE_TYPE) {
   const rendered = [...new Set(tokens)].map((token) => `{{${token}}}`).join(", ");
-  return `SystemOne Decision node "${nodeId}" has unresolved interpolation token(s): ${rendered}. ` + "No request was sent. Declare the value in the node's inputs mapping or fix the path.";
+  const label = SYSTEM_ONE_NODE_LABELS[nodeType] ?? SYSTEM_ONE_NODE_LABELS[SYSTEM_ONE_DECISION_NODE_TYPE];
+  return `${label} node "${nodeId}" has unresolved interpolation token(s): ${rendered}. ` + "No request was sent. Declare the value in the node's inputs mapping or fix the path.";
 }
 
 class SystemOneContractError extends Error {
 }
-function fail(message) {
+function fail2(message) {
   throw new SystemOneContractError(message);
 }
 function isRecord2(value) {
@@ -1199,18 +2117,18 @@ function isRecord2(value) {
 }
 function unit(value, what) {
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
-    fail(`${what} must be a finite number between 0 and 1`);
+    fail2(`${what} must be a finite number between 0 and 1`);
   }
   return value;
 }
 function distribution(value, keys, what) {
   if (!isRecord2(value))
-    fail(`${what} must be an object`);
+    fail2(`${what} must be an object`);
   const actual = Object.keys(value);
   const missing = keys.filter((key) => !Object.hasOwn(value, key));
   const extra = actual.filter((key) => !keys.includes(key));
   if (missing.length > 0 || extra.length > 0) {
-    fail(`${what} keys must be exactly the declared ${keys.length} option(s)` + (missing.length > 0 ? `; missing ${missing.length}` : "") + (extra.length > 0 ? `; ${extra.length} unexpected` : ""));
+    fail2(`${what} keys must be exactly the declared ${keys.length} option(s)` + (missing.length > 0 ? `; missing ${missing.length}` : "") + (extra.length > 0 ? `; ${extra.length} unexpected` : ""));
   }
   const out = {};
   let sum = 0;
@@ -1220,16 +2138,16 @@ function distribution(value, keys, what) {
     sum += p;
   }
   if (Math.abs(sum - 1) > DISTRIBUTION_TOLERANCE) {
-    fail(`${what} must sum to 1 (within ${DISTRIBUTION_TOLERANCE})`);
+    fail2(`${what} must sum to 1 (within ${DISTRIBUTION_TOLERANCE})`);
   }
   return out;
 }
-function validateAnswer(id, question, raw, confidenceField) {
+function validateAnswer2(id, question, raw, confidenceField) {
   const at = `answer "${id}"`;
   if (!isRecord2(raw))
-    fail(`${at} must be an object`);
+    fail2(`${at} must be an object`);
   if (raw.type !== question.type) {
-    fail(`${at} has type ${JSON.stringify(raw.type)} but the question declares "${question.type}"`);
+    fail2(`${at} has type ${JSON.stringify(raw.type)} but the question declares "${question.type}"`);
   }
   switch (question.type) {
     case "noul":
@@ -1237,7 +2155,7 @@ function validateAnswer(id, question, raw, confidenceField) {
     case "choice": {
       const options = Object.keys(question.criteria);
       if (typeof raw.choice !== "string" || !Object.hasOwn(question.criteria, raw.choice)) {
-        fail(`${at}.choice is not one of the declared options`);
+        fail2(`${at}.choice is not one of the declared options`);
       }
       return {
         type: "choice",
@@ -1250,17 +2168,17 @@ function validateAnswer(id, question, raw, confidenceField) {
       const indices = question.criteria.map((_, index) => String(index));
       const top = indices.length - 1;
       if (typeof raw.score !== "number" || !Number.isFinite(raw.score) || raw.score < 0 || raw.score > top) {
-        fail(`${at}.score must be a finite number between 0 and ${top}`);
+        fail2(`${at}.score must be a finite number between 0 and ${top}`);
       }
       if (!isRecord2(raw.legend))
-        fail(`${at}.legend must be an object`);
+        fail2(`${at}.legend must be an object`);
       const legend = {};
       for (const key of indices) {
         if (!Object.hasOwn(raw.legend, key))
-          fail(`${at}.legend is missing level ${key}`);
+          fail2(`${at}.legend is missing level ${key}`);
         const entry = SystemOneEntrySchema.safeParse(raw.legend[key]);
         if (!entry.success)
-          fail(`${at}.legend["${key}"] must be a string, object, array, or null`);
+          fail2(`${at}.legend["${key}"] must be a string, object, array, or null`);
         legend[key] = entry.data;
       }
       return {
@@ -1282,30 +2200,30 @@ function readRoutingModel(routing) {
 }
 function validateSystemOneResponse(questions, body, requestId, confidenceField = "confidence") {
   if (!isRecord2(body))
-    fail("response body must be a JSON object");
+    fail2("response body must be a JSON object");
   if (typeof body.model !== "string" || body.model === "") {
-    fail("response is missing the model that produced the answers");
+    fail2("response is missing the model that produced the answers");
   }
   if (!isRecord2(body.answers))
-    fail("response is missing the answers object");
+    fail2("response is missing the answers object");
   const usage = object2({ input_tokens: number2().int().min(0), output_tokens: number2().int().min(0) }).safeParse(body.usage);
   if (!usage.success)
-    fail("response usage must report non-negative integer input_tokens and output_tokens");
+    fail2("response usage must report non-negative integer input_tokens and output_tokens");
   const declared = Object.keys(questions);
   const unexpected = Object.keys(body.answers).filter((id) => !Object.hasOwn(questions, id));
   if (unexpected.length > 0)
-    fail(`response contains ${unexpected.length} answer(s) for undeclared questions`);
+    fail2(`response contains ${unexpected.length} answer(s) for undeclared questions`);
   const answers = {};
   for (const id of declared) {
     if (!Object.hasOwn(body.answers, id))
-      fail(`response is missing the answer for question "${id}"`);
+      fail2(`response is missing the answer for question "${id}"`);
     const question = questions[id];
     if (!question)
-      fail(`question "${id}" is not defined`);
-    answers[id] = validateAnswer(id, question, body.answers[id], confidenceField);
+      fail2(`question "${id}" is not defined`);
+    answers[id] = validateAnswer2(id, question, body.answers[id], confidenceField);
   }
   if (declared.length === 0)
-    fail("a system-one-decision call needs at least one question");
+    fail2("a system-one-decision call needs at least one question");
   const routingModel = readRoutingModel(body.routing);
   return {
     model: body.model,
@@ -1456,59 +2374,6 @@ function resolveReviewedDecision(parkedOutput, approval) {
   }
   return finish("approved", answers, questions);
 }
-var REQUEST_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
-var ERROR_CODE_RE2 = /^[A-Za-z0-9._:-]{1,64}$/;
-function readRequestId(headers) {
-  const value = headers.get("x-request-id") ?? headers.get("request-id") ?? headers.get("cf-ray");
-  return value && REQUEST_ID_RE.test(value) ? value : undefined;
-}
-function parseRetryAfter(value, now) {
-  if (!value)
-    return;
-  const trimmed = value.trim();
-  if (/^\d+(\.\d+)?$/.test(trimmed))
-    return Math.round(Number(trimmed) * 1000);
-  const at = Date.parse(trimmed);
-  return Number.isNaN(at) ? undefined : Math.max(0, at - now);
-}
-function readErrorCode(text) {
-  if (text.length === 0 || text.length > MAX_ERROR_BODY_CHARS)
-    return;
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    return;
-  }
-  if (!isRecord2(parsed))
-    return;
-  const nested = isRecord2(parsed.error) ? parsed.error : undefined;
-  const detail = isRecord2(parsed.detail) ? parsed.detail : undefined;
-  for (const candidate of [
-    nested?.code,
-    nested?.type,
-    detail?.error_type,
-    parsed.code,
-    parsed.type
-  ]) {
-    if (typeof candidate === "string" && ERROR_CODE_RE2.test(candidate))
-      return candidate;
-  }
-  return cloudflareErrorCode(parsed);
-}
-function defaultSleep(ms, signal) {
-  return new Promise((resolve) => {
-    if (signal.aborted)
-      return resolve();
-    const timer = setTimeout(done, ms);
-    function done() {
-      clearTimeout(timer);
-      signal.removeEventListener("abort", done);
-      resolve();
-    }
-    signal.addEventListener("abort", done, { once: true });
-  });
-}
 
 class SystemOneDecisionExecutor extends BaseExecutor {
   options;
@@ -1523,6 +2388,9 @@ class SystemOneDecisionExecutor extends BaseExecutor {
   providerContext() {
     return { db: this.deps.db, env: this.options.env ?? process.env };
   }
+  defaultProvider() {
+    return resolveSystemOneDefaultProvider(this.providerContext());
+  }
   resolveTarget(id, model) {
     return resolveSystemOneTarget(id, this.providerContext(), {
       apiKey: this.options.getApiKey,
@@ -1532,8 +2400,9 @@ class SystemOneDecisionExecutor extends BaseExecutor {
   }
   async checkReadiness(nodes) {
     const nodeIdsByProvider = new Map;
+    const defaultId = await this.defaultProvider();
     for (const node of nodes) {
-      const id = systemOneProviderOf(node.config);
+      const id = systemOneProviderOf(node.config, defaultId);
       if (id)
         nodeIdsByProvider.set(id, [...nodeIdsByProvider.get(id) ?? [], node.id]);
     }
@@ -1560,20 +2429,33 @@ class SystemOneDecisionExecutor extends BaseExecutor {
     return this.reviewDecision(config, config.humanReview, decided.output, context, meta);
   }
   async decide(config) {
-    const providerId = config.provider;
+    const providerId = config.provider ?? await this.defaultProvider();
     const provider = SYSTEM_ONE_PROVIDERS[providerId];
     const model = config.model ?? provider.defaultModel;
     const modelProblem = systemOneModelProblem(providerId, model);
     if (modelProblem)
       return { ok: false, error: modelProblem };
+    const limitProblem = systemOneQuestionLimitProblem(providerId, Object.keys(config.questions).length);
+    if (limitProblem)
+      return { ok: false, error: limitProblem };
     const target = await this.resolveTarget(providerId, model);
     if (!target.ok)
-      return { ok: false, error: target.error };
-    const { apiKey, endpoint } = target;
+      return target;
+    const { apiKey, endpoint, keyName } = target;
     const wire = provider.wire ?? SYSTEM_ONE_WIRE;
     const body = JSON.stringify(wire.buildRequest(config, model));
     const scrub = (message) => message.split(apiKey).join("[REDACTED]");
-    const sent = await this.send(providerId, endpoint, apiKey, body, config.timeoutMs, config.maxRetries);
+    const sent = await sendSystemOneRequest({
+      providerId,
+      capability: "decide",
+      endpoint,
+      apiKey,
+      keyName,
+      body,
+      timeoutMs: config.timeoutMs,
+      maxRetries: config.maxRetries,
+      env: this.providerContext().env
+    }, this.options);
     if (!sent.ok)
       return { ok: false, error: scrub(sent.error) };
     let parsed;
@@ -1663,128 +2545,6 @@ class SystemOneDecisionExecutor extends BaseExecutor {
   resolveApproval(parkedOutput, approval) {
     return resolveReviewedDecision(parkedOutput, approval);
   }
-  async send(providerId, endpoint, apiKey, body, timeoutMs, maxRetries) {
-    const doFetch = this.options.fetch ?? fetch;
-    const sleep = this.options.sleep ?? defaultSleep;
-    const now = this.options.now ?? Date.now;
-    const random = this.options.random ?? Math.random;
-    const deadlineAt = now() + timeoutMs - DEADLINE_MARGIN_MS;
-    const controller = new AbortController;
-    const timer = setTimeout(() => controller.abort(), Math.max(0, deadlineAt - now()));
-    const timedOut = () => ({
-      ok: false,
-      error: `SystemOne request exceeded its ${timeoutMs}ms time budget`
-    });
-    try {
-      for (let attempt = 0;; attempt++) {
-        const result = await this.attemptOnce(doFetch, providerId, endpoint, apiKey, body, controller.signal, now);
-        if (result.kind === "ok") {
-          return { ok: true, text: result.text, requestId: result.requestId };
-        }
-        if (result.kind === "timeout" || controller.signal.aborted)
-          return timedOut();
-        const attempts = attempt + 1;
-        const suffix = attempts > 1 ? ` after ${attempts} attempts` : "";
-        if (!result.retryable || attempt >= maxRetries) {
-          return { ok: false, error: `${result.message}${suffix}` };
-        }
-        const backoff = Math.min(BACKOFF_CAP_MS, BACKOFF_BASE_MS * 2 ** attempt);
-        const delay = result.retryAfterMs ?? Math.round(backoff * (0.5 + random() * 0.5));
-        if (delay >= deadlineAt - now()) {
-          return {
-            ok: false,
-            error: `${result.message}${suffix}; the ${delay}ms retry delay does not fit the ${timeoutMs}ms time budget`
-          };
-        }
-        await sleep(delay, controller.signal);
-        if (controller.signal.aborted)
-          return timedOut();
-      }
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-  async attemptOnce(doFetch, providerId, endpoint, apiKey, body, signal, now) {
-    let res;
-    try {
-      res = await doFetch(endpoint, {
-        method: "POST",
-        headers: {
-          ...getOpenRouterAttributionHeaders(endpoint, this.providerContext().env),
-          "content-type": "application/json",
-          accept: "application/json",
-          authorization: `Bearer ${apiKey}`
-        },
-        body,
-        redirect: "manual",
-        signal
-      });
-    } catch (err) {
-      if (signal.aborted)
-        return { kind: "timeout" };
-      const code = err?.code;
-      const detail = typeof code === "string" && /^[A-Z0-9_]{3,40}$/.test(code) ? ` (${code})` : "";
-      return {
-        kind: "fail",
-        message: `SystemOne request failed: network error${detail}`,
-        retryable: true
-      };
-    }
-    const requestId = readRequestId(res.headers);
-    const withId = (message) => requestId ? `${message} [request ${requestId}]` : message;
-    if (res.status >= 200 && res.status < 300) {
-      let text;
-      try {
-        text = await res.text();
-      } catch {
-        if (signal.aborted)
-          return { kind: "timeout" };
-        return {
-          kind: "fail",
-          message: withId("SystemOne response body could not be read"),
-          retryable: true
-        };
-      }
-      if (text.length > MAX_RESPONSE_CHARS) {
-        return {
-          kind: "fail",
-          message: withId("SystemOne response exceeded the size limit"),
-          retryable: false
-        };
-      }
-      return { kind: "ok", text, requestId };
-    }
-    if (res.status >= 300 && res.status < 400) {
-      return {
-        kind: "fail",
-        message: withId(`SystemOne request was redirected (HTTP ${res.status}); redirects are refused`),
-        retryable: false
-      };
-    }
-    let errorText = "";
-    try {
-      errorText = await res.text();
-    } catch {
-      if (signal.aborted)
-        return { kind: "timeout" };
-    }
-    const code = readErrorCode(errorText);
-    if (res.status === 401 || res.status === 403) {
-      return {
-        kind: "fail",
-        message: withId(systemOneKeyRejectedMessage(providerId, res.status, code)),
-        retryable: false
-      };
-    }
-    const detail = code ? ` (${code})` : "";
-    const retryable = res.status === 408 || res.status === 429 || res.status >= 500;
-    return {
-      kind: "fail",
-      message: withId(`SystemOne API returned HTTP ${res.status}${detail}`),
-      retryable,
-      retryAfterMs: retryable ? parseRetryAfter(res.headers.get("retry-after"), now()) : undefined
-    };
-  }
 }
 
 // src/workflows/definition.ts
@@ -1919,7 +2679,7 @@ function validateDefinition(def, registry, options = {}) {
     if (node.type === "human-in-the-loop" && typeof node.config.questions === "string" && !/^\{\{[^}]+\}\}$/.test(node.config.questions.trim())) {
       errors.push(`Node "${node.id}" human-in-the-loop config.questions must be an array or one exact {{interpolation}} token`);
     }
-    errors.push(...systemOneStaticShapeViolations(node), ...systemOneRetryViolations(node));
+    errors.push(...systemOneStaticShapeViolations(node), ...systemOneExtractionStaticShapeViolations(node), ...systemOneRetryViolations(node));
     if (node.type === "foreach") {
       validateForeachNode(node, errors);
       if (node.id.includes("#")) {
@@ -2120,4 +2880,4 @@ function applyDefinitionPatch(def, patch) {
   return { definition: patchedDef, errors };
 }
 
-export { BaseExecutor, postApprovalCancellationUpdates, createApprovalFollowUpTask, HumanInTheLoopExecutor, resolveWorkflowLlmConfig, SYSTEM_ONE_PROVIDER_IDS, SYSTEM_ONE_DECISION_NODE_TYPE, SystemOneDecisionConfigSchema, systemOneRetryViolations, systemOneUnresolvedError, SystemOneDecisionExecutor, getNextTargets, generateEdges, findEntryNodes, resolveValidationPort, getSuccessors, definitionNodeIds, validateDefinition, applyDefinitionPatch };
+export { BaseExecutor, postApprovalCancellationUpdates, createApprovalFollowUpTask, HumanInTheLoopExecutor, resolveWorkflowLlmConfig, SYSTEM_ONE_PROVIDER_IDS, SystemOneExtractionExecutor, SYSTEM_ONE_DECISION_NODE_TYPE, SystemOneDecisionConfigSchema, isSystemOneNodeType, systemOneRetryViolations, systemOneUnresolvedError, SystemOneDecisionExecutor, getNextTargets, generateEdges, findEntryNodes, resolveValidationPort, getSuccessors, definitionNodeIds, validateDefinition, applyDefinitionPatch };