@runtypelabs/cli 2.19.1 → 2.19.2

package/dist/index.js

@@ -15164,7 +15164,7 @@ var apiRoutingDocSchema = external_exports.object({
   path: ["api", "activeScript"]
 });
 
-// ../shared/dist/chunk-R66POVE6.mjs
+// ../shared/dist/chunk-7Y2SRVP7.mjs
 function getNestedValue(obj, path18) {
   let normalizedPath = path18;
   normalizedPath = normalizedPath.replace(/^\$\.?/, "");
@@ -15207,6 +15207,14 @@ var SYSTEM_VARIABLES = /* @__PURE__ */ new Set([
   "_record",
   "_now",
   "_schedule",
+  // `_tools` is engine-populated, but LATER than the other system vars: it is
+  // injected after tool resolution, just before dispatch (see
+  // `injectToolsSystemVariable` in the api prompt-executor), so a prompt may
+  // reference `{{_tools.interfaces}}` / `{{_tools.count}}` / `{{_tools.names}}`.
+  // It belongs to the system namespace so the validator / FPO gate don't flag
+  // it as undeclared and the executors don't report it as "unresolved" before
+  // injection runs.
+  "_tools",
   "messages",
   "userMessage",
   "lastMessage",
@@ -15355,6 +15363,18 @@ function stringifyValue(value) {
   if (typeof value === "object") return JSON.stringify(value);
   return String(value);
 }
+function extractTemplateExpressionPaths(expr) {
+  let parsed;
+  try {
+    parsed = parseTemplateExpression(expr);
+  } catch {
+    return [];
+  }
+  if (parsed.kind === "legacy") {
+    return parsed.variable ? [parsed.variable] : [];
+  }
+  return parsed.operands.filter((o) => o.kind === "path").map((o) => o.path);
+}
 var _SimpleTemplateEngine = class _SimpleTemplateEngine2 {
   substitute(template, context = {}) {
     const usedVariables = [];
@@ -15986,7 +16006,15 @@ var stepCompleteEventSchema = external_exports.object({
   stopReason: wireStopReasonSchema.optional(),
   stepId: external_exports.string().optional(),
   stepName: external_exports.string().optional(),
-  toolContext: toolContextSchema.optional()
+  toolContext: toolContextSchema.optional(),
+  // Template variables that were still unresolved (`{{...}}` left intact) when
+  // the prompt was dispatched to the model — the catch-all observability signal
+  // for a surviving token (a missing flow input, an undeclared variable, or an
+  // unknown-namespace typo). Only prompt steps populate it, and only when
+  // non-empty; absence means every reference resolved. Non-fatal: the step still
+  // ran. Sourced from the template engine's `missingVariables`, which already
+  // includes unknown-namespace tokens (see `TemplateSubstitutionResult`).
+  unresolvedVariables: external_exports.array(external_exports.string()).optional()
 });
 var stepErrorEventSchema = external_exports.object({
   ...baseFlowEvent,
@@ -16441,6 +16469,79 @@ var ExecuteToolSchema = external_exports.object({
     userId: external_exports.string()
   }).optional()
 });
+function parseToolInstanceId(toolId) {
+  const hashIndex = toolId.indexOf("#");
+  if (hashIndex === -1) {
+    return { baseId: toolId, instanceId: "" };
+  }
+  return {
+    baseId: toolId.substring(0, hashIndex),
+    instanceId: toolId.substring(hashIndex + 1)
+  };
+}
+function isBuiltInToolId(toolId) {
+  return toolId.startsWith("builtin:");
+}
+function isPlatformToolId(toolId) {
+  return toolId.startsWith("platform:");
+}
+var INTEGRATION_SERVER_IDS = /* @__PURE__ */ new Set(["slack", "google", "linear", "github", "telegram"]);
+function isBuiltInIntegrationToolId(toolId) {
+  if (!toolId.startsWith("builtin:")) return false;
+  const { baseId } = parseToolInstanceId(toolId);
+  const parts = baseId.split(":");
+  if (parts.length < 3) return false;
+  return INTEGRATION_SERVER_IDS.has(parts[1]);
+}
+function isMCPToolId(toolId) {
+  return toolId.startsWith("mcp:");
+}
+var NAMED_TOOL_REF_PREFIX = "tool:";
+function isNamedToolRef(toolId) {
+  return toolId.startsWith(NAMED_TOOL_REF_PREFIX) && toolId.length > NAMED_TOOL_REF_PREFIX.length;
+}
+function parseNamedToolRef(toolId) {
+  if (!isNamedToolRef(toolId)) return null;
+  return { name: toolId.slice(NAMED_TOOL_REF_PREFIX.length) };
+}
+function separateToolIds(toolIds) {
+  const builtInToolIds = [];
+  const platformToolIds = [];
+  const integrationToolIds = [];
+  const mcpToolIds = [];
+  const dataConnectionToolIds = [];
+  const namedToolIds = [];
+  const customToolIds = [];
+  for (const toolId of toolIds) {
+    if (isDataConnectionToolId(toolId)) {
+      dataConnectionToolIds.push(toolId);
+    } else if (isPlatformToolId(toolId)) {
+      platformToolIds.push(toolId);
+    } else if (isBuiltInIntegrationToolId(toolId)) {
+      integrationToolIds.push(toolId);
+    } else if (isBuiltInToolId(toolId)) {
+      builtInToolIds.push(toolId);
+    } else if (isMCPToolId(toolId)) {
+      mcpToolIds.push(toolId);
+    } else if (isNamedToolRef(toolId)) {
+      namedToolIds.push(toolId);
+    } else {
+      customToolIds.push(toolId);
+    }
+  }
+  return {
+    builtInToolIds,
+    platformToolIds,
+    integrationToolIds,
+    mcpToolIds,
+    dataConnectionToolIds,
+    namedToolIds,
+    customToolIds
+  };
+}
+function isDataConnectionToolId(toolId) {
+  return toolId.startsWith("dc:");
+}
 var contextFallbackSchema = external_exports.union([
   external_exports.object({ type: external_exports.literal("retry"), delay: external_exports.number().optional() }),
   external_exports.object({
@@ -17247,6 +17348,1923 @@ var CONTEXT_STEP_TYPES = [
   "memory-summary"
 ];
 var FLOW_STEP_TYPES = ["prompt", ...CONTEXT_STEP_TYPES];
+var DEFAULT_MANAGED_SEND_FROM_DOMAIN = "runtype.email";
+var STAGING_MANAGED_SEND_FROM_DOMAIN = "runtype-staging.email";
+var MANAGED_SEND_FROM_DOMAINS = [
+  DEFAULT_MANAGED_SEND_FROM_DOMAIN,
+  STAGING_MANAGED_SEND_FROM_DOMAIN
+];
+var MANAGED_TEMPLATE_SEND_FROM_ADDRESS_REGEX = /^{{\s*_flow\.id\s*}}@([^@\s]+)$/i;
+var LEGACY_MANAGED_SEND_FROM_ADDRESS_REGEX = /^[^@\s]+@messages\.runtype\.(com|ai)$/i;
+function normalizeFromAddress(configuredFrom) {
+  return configuredFrom?.trim() ?? "";
+}
+function normalizeDomain(domain2) {
+  return domain2?.trim().toLowerCase() ?? "";
+}
+function extractDomainFromAddress(fromAddress) {
+  const normalizedFrom = normalizeFromAddress(fromAddress);
+  const atIndex = normalizedFrom.lastIndexOf("@");
+  if (atIndex === -1) {
+    return void 0;
+  }
+  const domain2 = normalizedFrom.slice(atIndex + 1);
+  return normalizeDomain(domain2) || void 0;
+}
+function getReservedManagedSendFromDomains(preferredManagedDomain) {
+  const preferredDomain = normalizeDomain(preferredManagedDomain);
+  const reservedDomains = preferredDomain ? [preferredDomain, ...MANAGED_SEND_FROM_DOMAINS] : [...MANAGED_SEND_FROM_DOMAINS];
+  return Array.from(new Set(reservedDomains));
+}
+function isReservedManagedSendFromDomain(domain2, preferredManagedDomain) {
+  const normalizedDomain = normalizeDomain(domain2);
+  if (!normalizedDomain) {
+    return false;
+  }
+  return getReservedManagedSendFromDomains(preferredManagedDomain).includes(normalizedDomain);
+}
+function extractManagedTemplateDomain(configuredFrom) {
+  const normalizedFrom = normalizeFromAddress(configuredFrom);
+  const managedTemplateMatch = normalizedFrom.match(MANAGED_TEMPLATE_SEND_FROM_ADDRESS_REGEX);
+  return normalizeDomain(managedTemplateMatch?.[1]) || void 0;
+}
+function isManagedTemplateSendFromAddress(configuredFrom, preferredManagedDomain) {
+  return isReservedManagedSendFromDomain(
+    extractManagedTemplateDomain(configuredFrom),
+    preferredManagedDomain
+  );
+}
+function isLegacyManagedSendFromAddress(configuredFrom) {
+  return LEGACY_MANAGED_SEND_FROM_ADDRESS_REGEX.test(normalizeFromAddress(configuredFrom));
+}
+function shouldUseManagedSendFromAddress(configuredFrom, preferredManagedDomain) {
+  if (!normalizeFromAddress(configuredFrom)) {
+    return true;
+  }
+  return isManagedTemplateSendFromAddress(configuredFrom, preferredManagedDomain) || isLegacyManagedSendFromAddress(configuredFrom);
+}
+function isCustomSendFromAddressOnManagedDomain(configuredFrom, preferredManagedDomain) {
+  if (shouldUseManagedSendFromAddress(configuredFrom, preferredManagedDomain)) {
+    return false;
+  }
+  return isReservedManagedSendFromDomain(
+    extractDomainFromAddress(configuredFrom),
+    preferredManagedDomain
+  );
+}
+var NormalizationError = class extends Error {
+  constructor(message, stepType, fieldName, expectedType, actualValue) {
+    super(message);
+    this.stepType = stepType;
+    this.fieldName = fieldName;
+    this.expectedType = expectedType;
+    this.actualValue = actualValue;
+    this.name = "NormalizationError";
+  }
+};
+function validateRequired(value, fieldName, stepType) {
+  if (value === null || value === void 0 || value === "") {
+    throw new NormalizationError(
+      `Missing required field '${fieldName}' for ${stepType} step`,
+      stepType,
+      fieldName,
+      "non-null value",
+      value
+    );
+  }
+}
+function validateString(value, fieldName, stepType, required2 = false) {
+  if (required2) {
+    validateRequired(value, fieldName, stepType);
+  }
+  if (value !== void 0 && value !== null && typeof value !== "string") {
+    throw new NormalizationError(
+      `Field '${fieldName}' must be a string for ${stepType} step`,
+      stepType,
+      fieldName,
+      "string",
+      typeof value
+    );
+  }
+}
+function validateNumber(value, fieldName, stepType, required2 = false) {
+  if (required2) {
+    validateRequired(value, fieldName, stepType);
+  }
+  if (value !== void 0 && value !== null) {
+    const num = Number(value);
+    if (isNaN(num)) {
+      throw new NormalizationError(
+        `Field '${fieldName}' must be a number for ${stepType} step`,
+        stepType,
+        fieldName,
+        "number",
+        typeof value
+      );
+    }
+  }
+}
+function normalizeOptionalNumber(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  return Number(value);
+}
+function validateBoolean(value, fieldName, stepType, required2 = false) {
+  if (required2) {
+    validateRequired(value, fieldName, stepType);
+  }
+  if (value !== void 0 && value !== null && typeof value !== "boolean") {
+    throw new NormalizationError(
+      `Field '${fieldName}' must be a boolean for ${stepType} step`,
+      stepType,
+      fieldName,
+      "boolean",
+      typeof value
+    );
+  }
+}
+function validateEnum(value, allowedValues, fieldName, stepType, required2 = false) {
+  if (required2) {
+    validateRequired(value, fieldName, stepType);
+  }
+  if (value !== void 0 && value !== null && !allowedValues.includes(value)) {
+    throw new NormalizationError(
+      `Field '${fieldName}' must be one of [${allowedValues.join(", ")}] for ${stepType} step, got: ${value}`,
+      stepType,
+      fieldName,
+      `one of [${allowedValues.join(", ")}]`,
+      value
+    );
+  }
+}
+function validateObject(value, fieldName, stepType, required2 = false) {
+  if (required2) {
+    validateRequired(value, fieldName, stepType);
+  }
+  if (value !== void 0 && value !== null) {
+    if (typeof value !== "object" || Array.isArray(value)) {
+      throw new NormalizationError(
+        `Field '${fieldName}' must be an object for ${stepType} step`,
+        stepType,
+        fieldName,
+        "object",
+        Array.isArray(value) ? "array" : typeof value
+      );
+    }
+  }
+}
+function validateArray(value, fieldName, stepType, required2 = false) {
+  if (required2) {
+    validateRequired(value, fieldName, stepType);
+  }
+  if (value !== void 0 && value !== null && !Array.isArray(value)) {
+    throw new NormalizationError(
+      `Field '${fieldName}' must be an array for ${stepType} step`,
+      stepType,
+      fieldName,
+      "array",
+      typeof value
+    );
+  }
+}
+function validateConfig(config3, stepType) {
+  if (!config3 || typeof config3 !== "object" || Array.isArray(config3)) {
+    throw new NormalizationError(
+      `Config must be a valid object for ${stepType} step`,
+      stepType,
+      "config",
+      "object",
+      typeof config3
+    );
+  }
+}
+function normalizeErrorHandling(value) {
+  if (!value) return void 0;
+  if (typeof value === "object" && value !== null) {
+    const objectValue = value;
+    const onError = objectValue.onError || objectValue.on_error || "continue";
+    return {
+      onError: onError === "default" ? "continue" : onError,
+      fallbacks: objectValue.fallbacks
+    };
+  }
+  if (typeof value === "string") {
+    const validModes = ["fail", "continue", "fallback", "default"];
+    if (!validModes.includes(value)) {
+      return { onError: "continue" };
+    }
+    return {
+      onError: value === "default" ? "continue" : value
+    };
+  }
+  return void 0;
+}
+function validateAndNormalizeErrorHandling(value, fieldName, stepType) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") {
+    const validModes = ["fail", "continue", "fallback", "default"];
+    if (!validModes.includes(value)) {
+      throw new NormalizationError(
+        `Field '${fieldName}' must be one of [${validModes.join(", ")}] or an error handling object for ${stepType} step, got: ${value}`,
+        stepType,
+        fieldName,
+        `one of [${validModes.join(", ")}] or object`,
+        value
+      );
+    }
+  }
+  if (typeof value === "object" && value !== null) {
+    const objectValue = value;
+    const onError = objectValue.onError || objectValue.on_error;
+    if (onError) {
+      const validModes = ["fail", "continue", "fallback", "default"];
+      if (!validModes.includes(onError)) {
+        throw new NormalizationError(
+          `Field '${fieldName}.onError' must be one of [${validModes.join(", ")}] for ${stepType} step, got: ${onError}`,
+          stepType,
+          `${fieldName}.onError`,
+          `one of [${validModes.join(", ")}]`,
+          onError
+        );
+      }
+    }
+  }
+  return normalizeErrorHandling(value);
+}
+function normalizeContextStep(apiStep, options = {}) {
+  if (!apiStep || typeof apiStep !== "object") {
+    throw new NormalizationError(
+      "Step must be a valid object",
+      "unknown",
+      "apiStep",
+      "object",
+      typeof apiStep
+    );
+  }
+  validateRequired(apiStep.id, "id", apiStep.type || "unknown");
+  validateRequired(apiStep.type, "type", "step");
+  validateRequired(apiStep.name, "name", apiStep.type || "unknown");
+  validateRequired(apiStep.order, "order", apiStep.type || "unknown");
+  validateString(apiStep.id, "id", apiStep.type, true);
+  validateString(apiStep.type, "type", "step", true);
+  validateString(apiStep.name, "name", apiStep.type, true);
+  validateNumber(apiStep.order, "order", apiStep.type, true);
+  const validStepTypes = [
+    "crawl",
+    "fetch-url",
+    "retrieve-record",
+    "fetch-github",
+    "api-call",
+    "transform-data",
+    "template",
+    "conditional",
+    "set-variable",
+    "upsert-record",
+    "send-email",
+    "send-text",
+    "send-event",
+    "send-stream",
+    "update-record",
+    "search",
+    "generate-embedding",
+    "vector-search",
+    "tool-call",
+    "wait-until",
+    "paginate-api",
+    "store-vector",
+    "execute-agent",
+    "store-asset",
+    "generate-pdf",
+    "save-memory",
+    "recall-memory",
+    "memory-summary"
+  ];
+  if (!validStepTypes.includes(apiStep.type)) {
+    throw new NormalizationError(
+      `Unknown context step type: ${apiStep.type}. Must be one of: ${validStepTypes.join(", ")}`,
+      apiStep.type,
+      "type",
+      `one of [${validStepTypes.join(", ")}]`,
+      apiStep.type
+    );
+  }
+  const baseStep = {
+    id: apiStep.id,
+    type: apiStep.type,
+    name: apiStep.name,
+    order: apiStep.order,
+    enabled: apiStep.enabled ?? true
+  };
+  try {
+    switch (apiStep.type) {
+      case "crawl":
+        return {
+          ...baseStep,
+          type: "crawl",
+          config: normalizeCrawlConfig(apiStep.config)
+        };
+      case "fetch-url":
+        return {
+          ...baseStep,
+          type: "fetch-url",
+          config: normalizeFetchUrlConfig(apiStep.config)
+        };
+      case "retrieve-record":
+        return {
+          ...baseStep,
+          type: "retrieve-record",
+          config: normalizeRetrieveRecordConfig(apiStep.config)
+        };
+      case "fetch-github":
+        return {
+          ...baseStep,
+          type: "fetch-github",
+          config: normalizeFetchGithubConfig(apiStep.config)
+        };
+      case "api-call":
+        return {
+          ...baseStep,
+          type: "api-call",
+          config: normalizeApiCallConfig(apiStep.config)
+        };
+      case "transform-data":
+        return {
+          ...baseStep,
+          type: "transform-data",
+          config: normalizeTransformDataConfig(apiStep.config)
+        };
+      case "template":
+        return {
+          ...baseStep,
+          type: "template",
+          config: normalizeTemplateConfig(apiStep.config)
+        };
+      case "conditional":
+        return {
+          ...baseStep,
+          type: "conditional",
+          config: normalizeConditionalConfig(apiStep.config)
+        };
+      case "set-variable":
+        return {
+          ...baseStep,
+          type: "set-variable",
+          config: normalizeSetVariableConfig(apiStep.config)
+        };
+      case "upsert-record":
+        return {
+          ...baseStep,
+          type: "upsert-record",
+          config: normalizeUpsertRecordConfig(apiStep.config)
+        };
+      case "send-email":
+        return {
+          ...baseStep,
+          type: "send-email",
+          config: normalizeSendEmailConfig(apiStep.config, options)
+        };
+      case "send-text":
+        return {
+          ...baseStep,
+          type: "send-text",
+          config: normalizeSendTextConfig(apiStep.config)
+        };
+      case "send-event":
+        return {
+          ...baseStep,
+          type: "send-event",
+          config: normalizeSendEventConfig(apiStep.config)
+        };
+      case "send-stream":
+        return {
+          ...baseStep,
+          type: "send-stream",
+          config: normalizeSendStreamConfig(apiStep.config)
+        };
+      case "update-record":
+        return {
+          ...baseStep,
+          type: "update-record",
+          config: normalizeUpdateRecordConfig(apiStep.config)
+        };
+      case "search":
+        return {
+          ...baseStep,
+          type: "search",
+          config: normalizeSearchConfig(apiStep.config)
+        };
+      case "generate-embedding":
+        return {
+          ...baseStep,
+          type: "generate-embedding",
+          config: normalizeGenerateEmbeddingConfig(apiStep.config)
+        };
+      case "vector-search":
+        return {
+          ...baseStep,
+          type: "vector-search",
+          config: normalizeVectorSearchConfig(apiStep.config)
+        };
+      case "paginate-api":
+        return {
+          ...baseStep,
+          type: "paginate-api",
+          config: normalizePaginateApiConfig(apiStep.config)
+        };
+      case "store-vector":
+        return {
+          ...baseStep,
+          type: "store-vector",
+          config: normalizeStoreVectorConfig(apiStep.config)
+        };
+      case "tool-call":
+        return {
+          ...baseStep,
+          type: "tool-call",
+          config: normalizeToolCallConfig(apiStep.config)
+        };
+      case "wait-until":
+        return {
+          ...baseStep,
+          type: "wait-until",
+          config: normalizeWaitUntilConfig(apiStep.config)
+        };
+      case "execute-agent":
+        return {
+          ...baseStep,
+          type: "execute-agent",
+          config: normalizeExecuteAgentConfig(apiStep.config)
+        };
+      case "store-asset":
+        return {
+          ...baseStep,
+          type: "store-asset",
+          config: normalizeStoreAssetConfig(apiStep.config)
+        };
+      case "generate-pdf":
+        return {
+          ...baseStep,
+          type: "generate-pdf",
+          config: normalizeGeneratePdfConfig(apiStep.config)
+        };
+      case "save-memory":
+        return {
+          ...baseStep,
+          type: "save-memory",
+          config: normalizeSaveMemoryConfig(apiStep.config)
+        };
+      case "recall-memory":
+        return {
+          ...baseStep,
+          type: "recall-memory",
+          config: normalizeRecallMemoryConfig(apiStep.config)
+        };
+      case "memory-summary":
+        return {
+          ...baseStep,
+          type: "memory-summary",
+          config: normalizeMemorySummaryConfig(apiStep.config)
+        };
+      default:
+        throw new NormalizationError(
+          `Unknown context step type: ${apiStep.type}`,
+          apiStep.type,
+          "type",
+          "valid step type",
+          apiStep.type
+        );
+    }
+  } catch (error51) {
+    if (error51 instanceof NormalizationError) {
+      throw error51;
+    }
+    throw new NormalizationError(
+      `Failed to normalize ${apiStep.type} step: ${error51 instanceof Error ? error51.message : String(error51)}`,
+      apiStep.type,
+      void 0,
+      void 0,
+      error51
+    );
+  }
+}
+function normalizeHttpConfig(config3) {
+  validateObject(config3, "http", "http-config", true);
+  validateString(config3.url, "http.url", "http-config", true);
+  if (config3.method) {
+    validateEnum(
+      config3.method,
+      ["GET", "POST", "PUT", "DELETE", "PATCH"],
+      "http.method",
+      "http-config"
+    );
+  }
+  if (config3.headers !== void 0 && config3.headers !== null) {
+    validateObject(config3.headers, "http.headers", "http-config");
+  }
+  if (config3.timeout !== void 0 && config3.timeout !== null) {
+    validateNumber(config3.timeout, "http.timeout", "http-config");
+  }
+  return {
+    url: config3.url,
+    method: config3.method,
+    headers: config3.headers,
+    // Preserve user headers as-is
+    body: config3.body,
+    timeout: config3.timeout
+  };
+}
+function normalizeCrawlConfig(config3) {
+  validateConfig(config3, "crawl");
+  const url2 = config3.url;
+  validateString(url2, "url", "crawl", true);
+  validateString(config3.outputVariable ?? config3.output_variable, "outputVariable", "crawl", true);
+  const limitRaw = config3.limit;
+  const depthRaw = config3.depth;
+  const maxAgeRaw = config3.maxAge ?? config3.max_age;
+  const modifiedSince = config3.modifiedSince ?? config3.modified_since;
+  const setExtraHTTPHeaders = config3.setExtraHTTPHeaders ?? config3.set_extra_http_headers;
+  const gotoOptions = config3.gotoOptions ?? config3.goto_options;
+  const waitForSelector = config3.waitForSelector ?? config3.wait_for_selector;
+  const rejectResourceTypes = config3.rejectResourceTypes ?? config3.reject_resource_types;
+  const rejectRequestPattern = config3.rejectRequestPattern ?? config3.reject_request_pattern;
+  const userAgent = config3.userAgent ?? config3.user_agent;
+  const jsonOptions = config3.jsonOptions ?? config3.json_options;
+  const pollIntervalMsRaw = config3.pollIntervalMs ?? config3.poll_interval_ms;
+  const completionTimeoutMsRaw = config3.completionTimeoutMs ?? config3.completion_timeout_ms;
+  if (limitRaw !== void 0 && limitRaw !== null) validateNumber(limitRaw, "limit", "crawl");
+  if (depthRaw !== void 0 && depthRaw !== null) validateNumber(depthRaw, "depth", "crawl");
+  if (config3.source !== void 0) validateString(config3.source, "source", "crawl");
+  if (config3.formats !== void 0) validateArray(config3.formats, "formats", "crawl");
+  if (config3.render !== void 0) validateBoolean(config3.render, "render", "crawl");
+  if (maxAgeRaw !== void 0 && maxAgeRaw !== null) validateNumber(maxAgeRaw, "maxAge", "crawl");
+  if (modifiedSince !== void 0) validateString(modifiedSince, "modifiedSince", "crawl");
+  if (config3.options !== void 0) validateObject(config3.options, "options", "crawl");
+  if (config3.authenticate !== void 0) validateObject(config3.authenticate, "authenticate", "crawl");
+  if (config3.cookies !== void 0) validateArray(config3.cookies, "cookies", "crawl");
+  if (setExtraHTTPHeaders !== void 0) {
+    validateObject(setExtraHTTPHeaders, "setExtraHTTPHeaders", "crawl");
+  }
+  if (gotoOptions !== void 0) validateObject(gotoOptions, "gotoOptions", "crawl");
+  if (waitForSelector !== void 0) validateString(waitForSelector, "waitForSelector", "crawl");
+  if (rejectResourceTypes !== void 0) {
+    validateArray(rejectResourceTypes, "rejectResourceTypes", "crawl");
+  }
+  if (rejectRequestPattern !== void 0) {
+    if (typeof rejectRequestPattern !== "string" && !Array.isArray(rejectRequestPattern)) {
+      throw new NormalizationError(
+        "Field 'rejectRequestPattern' must be a string or array for crawl step",
+        "crawl",
+        "rejectRequestPattern",
+        "string | array",
+        typeof rejectRequestPattern
+      );
+    }
+  }
+  if (userAgent !== void 0) validateString(userAgent, "userAgent", "crawl");
+  if (jsonOptions !== void 0) validateObject(jsonOptions, "jsonOptions", "crawl");
+  if (config3.streamOutput !== void 0) validateBoolean(config3.streamOutput, "streamOutput", "crawl");
+  if (pollIntervalMsRaw !== void 0 && pollIntervalMsRaw !== null) {
+    validateNumber(pollIntervalMsRaw, "pollIntervalMs", "crawl");
+  }
+  if (completionTimeoutMsRaw !== void 0 && completionTimeoutMsRaw !== null) {
+    validateNumber(completionTimeoutMsRaw, "completionTimeoutMs", "crawl");
+  }
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling ?? config3.error_handling,
+    "errorHandling",
+    "crawl"
+  );
+  const limit = normalizeOptionalNumber(limitRaw);
+  const depth = normalizeOptionalNumber(depthRaw);
+  const maxAge = normalizeOptionalNumber(maxAgeRaw);
+  const pollIntervalMs = normalizeOptionalNumber(pollIntervalMsRaw);
+  const completionTimeoutMs = normalizeOptionalNumber(completionTimeoutMsRaw);
+  return {
+    url: url2,
+    limit,
+    depth,
+    source: config3.source,
+    formats: config3.formats,
+    render: config3.render,
+    maxAge,
+    modifiedSince,
+    options: config3.options,
+    authenticate: config3.authenticate,
+    cookies: config3.cookies,
+    setExtraHTTPHeaders,
+    gotoOptions,
+    waitForSelector,
+    rejectResourceTypes,
+    rejectRequestPattern,
+    userAgent,
+    jsonOptions,
+    outputVariable: config3.outputVariable ?? config3.output_variable,
+    streamOutput: config3.streamOutput ?? config3.stream_output,
+    errorHandling,
+    defaultValue: config3.defaultValue ?? config3.default_value,
+    pollIntervalMs,
+    completionTimeoutMs,
+    asyncCrawl: config3.asyncCrawl
+  };
+}
+function normalizeAuthConfig(config3) {
+  if (!config3) return void 0;
+  validateObject(config3, "auth", "auth-config", true);
+  validateEnum(
+    config3.type,
+    ["none", "bearer", "basic", "api-key", "custom"],
+    "auth.type",
+    "auth-config",
+    true
+  );
+  if (config3.token) validateString(config3.token, "auth.token", "auth-config");
+  if (config3.username) validateString(config3.username, "auth.username", "auth-config");
+  if (config3.password) validateString(config3.password, "auth.password", "auth-config");
+  if (config3.apiKey) validateString(config3.apiKey, "auth.apiKey", "auth-config");
+  if (config3.headerName) validateString(config3.headerName, "auth.headerName", "auth-config");
+  if (config3.customHeaders !== void 0 && config3.customHeaders !== null) {
+    validateObject(config3.customHeaders, "auth.customHeaders", "auth-config");
+  }
+  return {
+    type: config3.type,
+    token: config3.token,
+    username: config3.username,
+    password: config3.password,
+    apiKey: config3.apiKey,
+    headerName: config3.headerName,
+    customHeaders: config3.customHeaders
+  };
+}
+function normalizeFirecrawlConfig(config3) {
+  if (!config3) return void 0;
+  return {
+    formats: config3.formats,
+    actions: config3.actions,
+    location: config3.location,
+    maxAge: config3.maxAge,
+    storeInCache: config3.storeInCache,
+    onlyMainContent: config3.onlyMainContent,
+    jsonSchema: config3.jsonSchema,
+    jsonPrompt: config3.jsonPrompt
+  };
+}
+function normalizeFetchUrlConfig(config3) {
+  validateConfig(config3, "fetch-url");
+  validateObject(config3.http, "http", "fetch-url", true);
+  validateString(config3.outputVariable, "outputVariable", "fetch-url", true);
+  if (config3.responseType) {
+    validateEnum(config3.responseType, ["json", "text", "xml"], "responseType", "fetch-url");
+  }
+  if (config3.markdownIfAvailable !== void 0) {
+    validateBoolean(config3.markdownIfAvailable, "markdownIfAvailable", "fetch-url");
+  }
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling,
+    "errorHandling",
+    "fetch-url"
+  );
+  if (config3.fetchMethod) {
+    validateEnum(config3.fetchMethod, ["standard", "firecrawl"], "fetchMethod", "fetch-url");
+  }
+  return {
+    http: normalizeHttpConfig(config3.http),
+    auth: normalizeAuthConfig(config3.auth),
+    responseType: config3.responseType,
+    markdownIfAvailable: config3.markdownIfAvailable,
+    outputVariable: config3.outputVariable,
+    streamOutput: config3.streamOutput,
+    errorHandling,
+    defaultValue: config3.defaultValue,
+    fetchMethod: config3.fetchMethod,
+    firecrawl: normalizeFirecrawlConfig(config3.firecrawl)
+  };
+}
+function normalizeRetrieveRecordConfig(config3) {
+  validateConfig(config3, "retrieve-record");
+  const filter = config3.recordFilter;
+  const hasFilter = filter && typeof filter === "object" && typeof filter.type === "string" && filter.type.length > 0;
+  if (!config3.recordId && !config3.recordType && !config3.recordName && !hasFilter) {
+    throw new NormalizationError(
+      `retrieve-record step requires at least one of 'recordId', 'recordType', 'recordName', or 'recordFilter'`,
+      "retrieve-record",
+      "recordId/recordType/recordName/recordFilter",
+      "at least one identification field",
+      void 0
+    );
+  }
+  validateString(config3.outputVariable, "outputVariable", "retrieve-record", true);
+  if (config3.fieldsToInclude)
+    validateString(config3.fieldsToInclude, "fieldsToInclude", "retrieve-record");
+  if (config3.fieldsToExclude)
+    validateString(config3.fieldsToExclude, "fieldsToExclude", "retrieve-record");
+  if (config3.availableFields)
+    validateArray(config3.availableFields, "availableFields", "retrieve-record");
+  return {
+    retrievalMode: config3.retrievalMode,
+    recordType: config3.recordType,
+    recordName: config3.recordName,
+    recordId: config3.recordId,
+    recordFilter: config3.recordFilter,
+    fieldsToInclude: config3.fieldsToInclude,
+    fieldsToExclude: config3.fieldsToExclude,
+    availableFields: config3.availableFields,
+    outputVariable: config3.outputVariable
+  };
+}
+function normalizeFetchGithubConfig(config3) {
+  validateConfig(config3, "fetch-github");
+  validateString(config3.repository, "repository", "fetch-github", true);
+  validateString(config3.outputVariable, "outputVariable", "fetch-github", true);
+  if (config3.path) validateString(config3.path, "path", "fetch-github");
+  if (config3.branch) validateString(config3.branch, "branch", "fetch-github");
+  if (config3.token) validateString(config3.token, "token", "fetch-github");
+  if (config3.contentType) {
+    validateEnum(config3.contentType, ["raw", "metadata", "both"], "contentType", "fetch-github");
+  }
+  if (config3.includePatterns)
+    validateArray(config3.includePatterns, "includePatterns", "fetch-github");
+  if (config3.excludePatterns)
+    validateArray(config3.excludePatterns, "excludePatterns", "fetch-github");
+  if (config3.compress !== void 0 && config3.compress !== null) {
+    validateBoolean(config3.compress, "compress", "fetch-github");
+  }
+  if (config3.style) {
+    validateEnum(config3.style, ["xml", "json", "markdown"], "style", "fetch-github");
+  }
+  return {
+    repository: config3.repository,
+    path: config3.path,
+    branch: config3.branch,
+    token: config3.token,
+    outputVariable: config3.outputVariable,
+    contentType: config3.contentType,
+    includePatterns: config3.includePatterns,
+    excludePatterns: config3.excludePatterns,
+    compress: config3.compress,
+    style: config3.style
+  };
+}
+function normalizeApiCallConfig(config3) {
+  validateConfig(config3, "api-call");
+  validateObject(config3.http, "http", "api-call", true);
+  validateString(config3.outputVariable, "outputVariable", "api-call", true);
+  if (config3.requestTemplate !== void 0 && config3.requestTemplate !== null) {
+    validateString(config3.requestTemplate, "requestTemplate", "api-call");
+  }
+  if (config3.responseMapping !== void 0 && config3.responseMapping !== null) {
+    validateObject(config3.responseMapping, "responseMapping", "api-call");
+  }
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling,
+    "errorHandling",
+    "api-call"
+  );
+  return {
+    http: normalizeHttpConfig(config3.http),
+    auth: normalizeAuthConfig(config3.auth),
+    requestTemplate: config3.requestTemplate,
+    responseMapping: config3.responseMapping,
+    // Preserve user mapping keys
+    outputVariable: config3.outputVariable,
+    errorHandling,
+    defaultValue: config3.defaultValue
+  };
+}
+function normalizeTransformDataConfig(config3) {
+  validateConfig(config3, "transform-data");
+  validateString(config3.script, "script", "transform-data", true);
+  const outputVariable = config3.outputVariable ?? config3.output_variable;
+  validateString(outputVariable, "outputVariable", "transform-data", true);
+  if (config3.sandboxProvider) {
+    validateEnum(
+      config3.sandboxProvider,
+      ["quickjs", "daytona", "cloudflare-worker", "runtype-sandbox", "cloudflare-sandbox"],
+      "sandboxProvider",
+      "transform-data"
+    );
+    if (config3.sandboxProvider === "cloudflare-sandbox") {
+      config3.sandboxProvider = "runtype-sandbox";
+    }
+  }
+  if (config3.language) {
+    validateEnum(
+      config3.language,
+      ["javascript", "typescript", "python"],
+      "language",
+      "transform-data"
+    );
+  }
+  if (config3.persistSandbox !== void 0 && typeof config3.persistSandbox !== "boolean") {
+    throw new NormalizationError(
+      "persistSandbox must be a boolean",
+      "transform-data",
+      "persistSandbox",
+      "boolean",
+      config3.persistSandbox
+    );
+  }
+  if (config3.streamOutput !== void 0) {
+    validateBoolean(config3.streamOutput, "streamOutput", "transform-data");
+  }
+  if (config3.reuseSandboxId !== void 0) {
+    validateString(config3.reuseSandboxId, "reuseSandboxId", "transform-data", false);
+  }
+  if (config3.inputMode) {
+    validateEnum(config3.inputMode, ["code", "variable"], "inputMode", "transform-data");
+  }
+  if (config3.packageJson && typeof config3.packageJson !== "string") {
+    throw new NormalizationError("packageJson must be a string", "transform-data");
+  }
+  if (config3.networkAccess !== void 0) {
+    if (config3.networkAccess !== "on" && config3.networkAccess !== "off") {
+      if (typeof config3.networkAccess !== "object" || config3.networkAccess === null || !Array.isArray(config3.networkAccess.allowedHostnames)) {
+        throw new NormalizationError(
+          "networkAccess must be 'on', 'off', or { allowedHostnames: string[] }",
+          "transform-data",
+          "networkAccess"
+        );
+      }
+      if (config3.networkAccess.allowedHostnames.length === 0) {
+        throw new NormalizationError(
+          "allowedHostnames must contain at least one entry",
+          "transform-data",
+          "networkAccess"
+        );
+      }
+      for (const h2 of config3.networkAccess.allowedHostnames) {
+        if (typeof h2 !== "string") {
+          throw new NormalizationError(
+            "allowedHostnames entries must be strings",
+            "transform-data",
+            "networkAccess"
+          );
+        }
+      }
+    }
+  }
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling,
+    "errorHandling",
+    "transform-data"
+  );
+  return {
+    script: config3.script,
+    outputVariable,
+    streamOutput: config3.streamOutput,
+    sandboxProvider: config3.sandboxProvider,
+    language: config3.language,
+    inputMode: config3.inputMode,
+    packageJson: config3.packageJson,
+    persistSandbox: config3.persistSandbox,
+    reuseSandboxId: config3.reuseSandboxId,
+    networkAccess: config3.networkAccess,
+    errorHandling,
+    defaultValue: config3.defaultValue,
+    ...config3.tools ? { tools: config3.tools } : {}
+  };
+}
+function normalizeTemplateConfig(config3) {
+  validateConfig(config3, "template");
+  validateString(config3.template, "template", "template", true);
+  validateString(config3.outputVariable, "outputVariable", "template", true);
+  validateEnum(
+    config3.outputFormat,
+    ["html", "email-html", "markdown", "pdf", "text"],
+    "outputFormat",
+    "template"
+  );
+  if (config3.inputs !== void 0) {
+    if (typeof config3.inputs !== "object" || config3.inputs === null || Array.isArray(config3.inputs)) {
+      throw new NormalizationError("inputs must be an object", "template", "inputs");
+    }
+    for (const [key, value] of Object.entries(config3.inputs)) {
+      if (typeof value !== "string") {
+        throw new NormalizationError(
+          `inputs.${key} must be a string expression`,
+          "template",
+          `inputs.${key}`
+        );
+      }
+    }
+  }
+  if (config3.partials !== void 0) {
+    if (typeof config3.partials !== "object" || config3.partials === null || Array.isArray(config3.partials)) {
+      throw new NormalizationError("partials must be an object", "template", "partials");
+    }
+    for (const [key, value] of Object.entries(config3.partials)) {
+      if (!/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(key)) {
+        throw new NormalizationError(
+          `partials.${key} key must be a simple identifier`,
+          "template",
+          `partials.${key}`
+        );
+      }
+      if (typeof value !== "string") {
+        throw new NormalizationError(
+          `partials.${key} must be a string template`,
+          "template",
+          `partials.${key}`
+        );
+      }
+    }
+  }
+  if (config3.pdfOptions !== void 0 && config3.outputFormat !== "pdf") {
+    throw new NormalizationError(
+      'pdfOptions is only allowed when outputFormat is "pdf"',
+      "template",
+      "pdfOptions"
+    );
+  }
+  if (config3.asArtifact !== void 0 && typeof config3.asArtifact !== "boolean") {
+    throw new NormalizationError("asArtifact must be a boolean", "template", "asArtifact");
+  }
+  if (config3.sampleData !== void 0) {
+    validateArray(config3.sampleData, "sampleData", "template");
+    for (const [i, scenario] of config3.sampleData.entries()) {
+      if (typeof scenario !== "object" || scenario === null || Array.isArray(scenario)) {
+        throw new NormalizationError(`sampleData[${i}] must be an object`, "template", `sampleData[${i}]`);
+      }
+      validateString(scenario.name, `sampleData[${i}].name`, "template", true);
+      if (typeof scenario.data !== "object" || scenario.data === null || Array.isArray(scenario.data)) {
+        throw new NormalizationError(`sampleData[${i}].data must be an object`, "template", `sampleData[${i}].data`);
+      }
+    }
+  }
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling,
+    "errorHandling",
+    "template"
+  );
+  return {
+    template: config3.template,
+    inputs: config3.inputs,
+    outputFormat: config3.outputFormat,
+    outputVariable: config3.outputVariable,
+    partials: config3.partials,
+    pdfOptions: config3.pdfOptions,
+    asArtifact: config3.asArtifact,
+    streamOutput: config3.streamOutput,
+    errorHandling,
+    defaultValue: config3.defaultValue,
+    sampleData: config3.sampleData
+  };
+}
+function normalizeConditionalConfig(config3) {
+  validateConfig(config3, "conditional");
+  validateString(config3.condition, "condition", "conditional", true);
+  const trueSteps = config3.trueSteps ?? config3.true_steps;
+  const falseSteps = config3.falseSteps ?? config3.false_steps;
+  if (trueSteps) {
+    validateArray(trueSteps, "trueSteps", "conditional");
+  }
+  if (falseSteps) {
+    validateArray(falseSteps, "falseSteps", "conditional");
+  }
+  const normalizeNestedSteps = (steps, parentStepId = "conditional") => {
+    return steps.map((step, index) => {
+      const stepWithDefaults = {
+        ...step,
+        id: step.id || `${parentStepId}-nested-${index}-${Date.now()}`,
+        order: step.order ?? index
+      };
+      if (step.type === "prompt") {
+        return stepWithDefaults;
+      }
+      return normalizeContextStep(stepWithDefaults);
+    });
+  };
+  return {
+    condition: config3.condition,
+    trueSteps: trueSteps ? normalizeNestedSteps(trueSteps, "conditional-true") : [],
+    falseSteps: falseSteps ? normalizeNestedSteps(falseSteps, "conditional-false") : void 0
+  };
+}
+function normalizeSetVariableConfig(config3) {
+  validateConfig(config3, "set-variable");
+  const variableName = config3.variableName ?? config3.variable_name;
+  validateString(variableName, "variableName", "set-variable", true);
+  if (config3.value === void 0) {
+    throw new NormalizationError(
+      `Missing required field 'value' for set-variable step`,
+      "set-variable",
+      "value",
+      "any value",
+      void 0
+    );
+  }
+  if (config3.valueTemplate !== void 0 && config3.valueTemplate !== null) {
+    validateString(config3.valueTemplate, "valueTemplate", "set-variable");
+  }
+  return {
+    variableName,
+    value: config3.value,
+    valueTemplate: config3.valueTemplate
+  };
+}
+function normalizeUpsertRecordConfig(config3) {
+  validateConfig(config3, "upsert-record");
+  validateString(config3.recordType, "recordType", "upsert-record", true);
+  validateString(config3.sourceVariable, "sourceVariable", "upsert-record", true);
+  validateString(config3.outputVariable, "outputVariable", "upsert-record", true);
+  if (config3.recordName !== void 0 && config3.recordName !== null) {
+    validateString(config3.recordName, "recordName", "upsert-record");
+  }
+  if (config3.mergeStrategy) {
+    validateEnum(config3.mergeStrategy, ["merge", "replace"], "mergeStrategy", "upsert-record");
+  }
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling,
+    "errorHandling",
+    "upsert-record"
+  );
+  if (config3.inputMode) {
+    validateEnum(config3.inputMode, ["single", "batch"], "inputMode", "upsert-record");
+  }
+  return {
+    recordType: config3.recordType,
+    recordName: config3.recordName,
+    sourceVariable: config3.sourceVariable,
+    outputVariable: config3.outputVariable,
+    mergeStrategy: config3.mergeStrategy,
+    errorHandling,
+    defaultValue: config3.defaultValue,
+    // Batch mode
+    inputMode: config3.inputMode,
+    inputVariable: config3.inputVariable,
+    itemAlias: config3.itemAlias,
+    metadataMapping: config3.metadataMapping,
+    batchSize: config3.batchSize
+  };
+}
+function normalizeSendEmailConfig(config3, options = {}) {
+  validateConfig(config3, "send-email");
+  validateString(config3.from, "from", "send-email");
+  validateString(config3.to, "to", "send-email", true);
+  validateString(config3.subject, "subject", "send-email", true);
+  if (isCustomSendFromAddressOnManagedDomain(config3.from, options.managedSendFromDomain)) {
+    throw new NormalizationError(
+      "Field 'from' cannot use the platform-managed email domain for a custom sender",
+      "send-email",
+      "from",
+      "custom email address on a non-managed domain",
+      config3.from
+    );
+  }
+  validateString(config3.outputVariable, "outputVariable", "send-email", true);
+  if (config3.replyTo) validateString(config3.replyTo, "replyTo", "send-email");
+  if (config3.cc) validateString(config3.cc, "cc", "send-email");
+  if (config3.bcc) validateString(config3.bcc, "bcc", "send-email");
+  if (config3.html) validateString(config3.html, "html", "send-email");
+  if (config3.text) validateString(config3.text, "text", "send-email");
+  if (config3.attachments) {
+    validateArray(config3.attachments, "attachments", "send-email");
+  }
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling,
+    "errorHandling",
+    "send-email"
+  );
+  return {
+    from: config3.from,
+    to: config3.to,
+    subject: config3.subject,
+    replyTo: config3.replyTo,
+    cc: config3.cc,
+    bcc: config3.bcc,
+    html: config3.html,
+    text: config3.text,
+    attachments: config3.attachments,
+    outputVariable: config3.outputVariable,
+    errorHandling,
+    defaultValue: config3.defaultValue
+  };
+}
+function normalizeSendTextConfig(config3) {
+  validateConfig(config3, "send-text");
+  validateString(config3.from, "from", "send-text", true);
+  validateString(config3.to, "to", "send-text", true);
+  validateString(config3.message, "message", "send-text", true);
+  validateString(config3.outputVariable, "outputVariable", "send-text", true);
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling,
+    "errorHandling",
+    "send-text"
+  );
+  return {
+    from: config3.from,
+    to: config3.to,
+    message: config3.message,
+    outputVariable: config3.outputVariable,
+    errorHandling,
+    defaultValue: config3.defaultValue
+  };
+}
+function normalizeSendEventConfig(config3) {
+  validateConfig(config3, "send-event");
+  validateEnum(
+    config3.provider,
+    ["posthog", "google-analytics", "amplitude", "segment"],
+    "provider",
+    "send-event",
+    true
+  );
+  validateString(config3.eventName, "eventName", "send-event", true);
+  validateString(config3.outputVariable, "outputVariable", "send-event", true);
+  if (config3.properties !== void 0 && config3.properties !== null) {
+    validateObject(config3.properties, "properties", "send-event");
+  }
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling,
+    "errorHandling",
+    "send-event"
+  );
+  return {
+    provider: config3.provider,
+    eventName: config3.eventName,
+    properties: config3.properties,
+    // Preserve user property keys as-is
+    outputVariable: config3.outputVariable,
+    errorHandling,
+    defaultValue: config3.defaultValue
+  };
+}
+function normalizeSendStreamConfig(config3) {
+  validateConfig(config3, "send-stream");
+  validateString(config3.message, "message", "send-stream", true);
+  return {
+    message: config3.message
+  };
+}
+function normalizeUpdateRecordConfig(config3) {
+  validateConfig(config3, "update-record");
+  const filter = config3.recordFilter;
+  const hasFilter = filter && typeof filter === "object" && typeof filter.type === "string" && filter.type.length > 0;
+  if (!config3.recordId && !(config3.recordType && config3.recordName) && !hasFilter) {
+    throw new NormalizationError(
+      `update-record step requires either 'recordId', both 'recordType' and 'recordName', or 'recordFilter'`,
+      "update-record",
+      "recordId/recordType/recordName/recordFilter",
+      "at least one identification method",
+      void 0
+    );
+  }
+  validateObject(config3.updates, "updates", "update-record", true);
+  validateString(config3.outputVariable, "outputVariable", "update-record", true);
+  validateEnum(
+    config3.mergeStrategy,
+    ["merge", "replace", "deep-merge"],
+    "mergeStrategy",
+    "update-record",
+    true
+  );
+  if (config3.updatesTemplate !== void 0 && config3.updatesTemplate !== null) {
+    validateString(config3.updatesTemplate, "updatesTemplate", "update-record");
+  }
+  if (config3.includeFullRecord !== void 0 && config3.includeFullRecord !== null) {
+    validateBoolean(config3.includeFullRecord, "includeFullRecord", "update-record");
+  }
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling,
+    "errorHandling",
+    "update-record"
+  );
+  return {
+    recordId: config3.recordId,
+    recordType: config3.recordType,
+    recordName: config3.recordName,
+    recordFilter: config3.recordFilter,
+    updates: config3.updates,
+    // Preserve user metadata keys as-is
+    updatesTemplate: config3.updatesTemplate,
+    mergeStrategy: config3.mergeStrategy,
+    outputVariable: config3.outputVariable,
+    includeFullRecord: config3.includeFullRecord,
+    errorHandling,
+    defaultValue: config3.defaultValue
+  };
+}
+function normalizeSearchConfig(config3) {
+  validateConfig(config3, "search");
+  validateString(config3.provider, "provider", "search", true);
+  validateString(config3.query, "query", "search", true);
+  validateString(config3.outputVariable, "outputVariable", "search", true);
+  if (config3.maxResults !== void 0 && config3.maxResults !== null) {
+    validateNumber(config3.maxResults, "maxResults", "search");
+  }
+  if (config3.maxTokens !== void 0 && config3.maxTokens !== null) {
+    validateNumber(config3.maxTokens, "maxTokens", "search");
+  }
+  if (config3.temperature !== void 0 && config3.temperature !== null) {
+    validateNumber(config3.temperature, "temperature", "search");
+  }
+  if (config3.returnCitations !== void 0 && config3.returnCitations !== null) {
+    validateBoolean(config3.returnCitations, "returnCitations", "search");
+  }
+  if (config3.allowedDomains) validateArray(config3.allowedDomains, "allowedDomains", "search");
+  if (config3.blockedDomains) validateArray(config3.blockedDomains, "blockedDomains", "search");
+  if (config3.sources) validateArray(config3.sources, "sources", "search");
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling,
+    "errorHandling",
+    "search"
+  );
+  return {
+    provider: config3.provider,
+    query: config3.query,
+    maxResults: config3.maxResults,
+    returnCitations: config3.returnCitations,
+    dateRange: config3.dateRange,
+    allowedDomains: config3.allowedDomains,
+    blockedDomains: config3.blockedDomains,
+    userLocation: config3.userLocation,
+    sources: config3.sources,
+    temperature: config3.temperature,
+    maxTokens: config3.maxTokens,
+    // Exa-specific options
+    exaSearchType: config3.exaSearchType,
+    exaContents: config3.exaContents,
+    exaCategory: config3.exaCategory,
+    outputVariable: config3.outputVariable,
+    errorHandling,
+    defaultValue: config3.defaultValue
+  };
+}
+function normalizeGenerateEmbeddingConfig(config3) {
+  validateConfig(config3, "generate-embedding");
+  const isBatchMode = config3.inputMode === "batch";
+  validateString(config3.outputVariable, "outputVariable", "generate-embedding", true);
+  if (isBatchMode) {
+    validateString(config3.inputVariable, "inputVariable", "generate-embedding", true);
+    if (config3.textTemplate)
+      validateString(config3.textTemplate, "textTemplate", "generate-embedding");
+    if (config3.itemAlias) validateString(config3.itemAlias, "itemAlias", "generate-embedding");
+    if (config3.batchSize !== void 0 && config3.batchSize !== null) {
+      validateNumber(config3.batchSize, "batchSize", "generate-embedding");
+    }
+  } else {
+    validateEnum(
+      config3.inputSource,
+      ["text", "variable", "record"],
+      "inputSource",
+      "generate-embedding",
+      true
+    );
+    if (config3.inputSource === "text") {
+      if (config3.text !== void 0 && config3.text !== null) {
+        validateString(config3.text, "text", "generate-embedding");
+      }
+    } else if (config3.inputSource === "variable") {
+      validateString(config3.variableName, "variableName", "generate-embedding", true);
+    } else if (config3.inputSource === "record") {
+      if (!config3.recordId && !(config3.recordType && config3.recordName)) {
+        throw new NormalizationError(
+          `generate-embedding step with inputSource='record' requires either 'recordId' or both 'recordType' and 'recordName'`,
+          "generate-embedding",
+          "recordId/recordType/recordName",
+          "at least one identification method",
+          void 0
+        );
+      }
+    }
+  }
+  if (config3.embeddingModel)
+    validateString(config3.embeddingModel, "embeddingModel", "generate-embedding");
+  if (config3.textField) validateString(config3.textField, "textField", "generate-embedding");
+  if (config3.maxLength !== void 0 && config3.maxLength !== null) {
+    validateNumber(config3.maxLength, "maxLength", "generate-embedding");
+  }
+  if (config3.storeInRecord !== void 0 && config3.storeInRecord !== null) {
+    validateBoolean(config3.storeInRecord, "storeInRecord", "generate-embedding");
+  }
+  return {
+    inputSource: config3.inputSource,
+    text: config3.text,
+    variableName: config3.variableName,
+    recordId: config3.recordId,
+    recordType: config3.recordType,
+    recordName: config3.recordName,
+    textField: config3.textField,
+    storeInRecord: config3.storeInRecord,
+    embeddingModel: config3.embeddingModel,
+    maxLength: config3.maxLength,
+    outputVariable: config3.outputVariable,
+    streamOutput: config3.streamOutput,
+    // Batch mode fields
+    inputMode: config3.inputMode,
+    inputVariable: config3.inputVariable,
+    textTemplate: config3.textTemplate,
+    itemAlias: config3.itemAlias,
+    batchSize: config3.batchSize
+  };
+}
+function normalizeVectorSearchConfig(config3) {
+  validateConfig(config3, "vector-search");
+  validateString(config3.query, "query", "vector-search", true);
+  validateString(config3.outputVariable, "outputVariable", "vector-search", true);
+  if (config3.embeddingModel)
+    validateString(config3.embeddingModel, "embeddingModel", "vector-search");
+  if (config3.limit !== void 0 && config3.limit !== null) {
+    validateNumber(config3.limit, "limit", "vector-search");
+  }
+  if (config3.threshold !== void 0 && config3.threshold !== null) {
+    validateNumber(config3.threshold, "threshold", "vector-search");
+  }
+  if (config3.recordType) validateString(config3.recordType, "recordType", "vector-search");
+  if (config3.metadataFilters !== void 0 && config3.metadataFilters !== null) {
+    validateObject(config3.metadataFilters, "metadataFilters", "vector-search");
+  }
+  if (config3.includeEmbedding !== void 0 && config3.includeEmbedding !== null) {
+    validateBoolean(config3.includeEmbedding, "includeEmbedding", "vector-search");
+  }
+  const providerInput = config3.provider || config3.vectorStore || "record";
+  const vectorStore = providerInput === "record" ? "pgvector" : providerInput;
+  const vectorizeConfig = config3.vectorizeConfigId || config3.vectorizeNamespace ? {
+    configId: config3.vectorizeConfigId,
+    namespace: config3.vectorizeNamespace
+  } : void 0;
+  const weaviateConfig = config3.weaviateClassName || config3.weaviateConfigId ? {
+    configId: config3.weaviateConfigId,
+    className: config3.weaviateClassName || ""
+  } : void 0;
+  return {
+    query: config3.query,
+    embeddingModel: config3.embeddingModel,
+    limit: config3.limit,
+    threshold: config3.threshold,
+    recordType: config3.recordType,
+    metadataFilters: config3.metadataFilters,
+    // Preserve user filter keys
+    outputVariable: config3.outputVariable,
+    includeEmbedding: config3.includeEmbedding,
+    streamOutput: config3.streamOutput,
+    // Provider selection and provider-specific config (typed fields)
+    vectorStore,
+    vectorizeConfig,
+    weaviateConfig,
+    // Also pass through flat fields for executor compatibility
+    // These are used by the executor which checks both patterns
+    provider: providerInput,
+    // Keep original for executor
+    vectorizeConfigId: config3.vectorizeConfigId,
+    vectorizeNamespace: config3.vectorizeNamespace,
+    weaviateClassName: config3.weaviateClassName,
+    hybridSearch: config3.hybridSearch,
+    hybridAlpha: config3.hybridAlpha,
+    weaviateProperties: config3.weaviateProperties
+  };
+}
+function normalizePaginateApiConfig(config3) {
+  validateConfig(config3, "paginate-api");
+  const url2 = config3.http?.url || config3.url;
+  validateString(url2, "url", "paginate-api", true);
+  const method = config3.http?.method || config3.method || "GET";
+  validateEnum(method, ["GET", "POST"], "method", "paginate-api");
+  const headers = config3.http?.headers ?? config3.headers;
+  if (headers !== void 0 && headers !== null) {
+    validateObject(headers, "headers", "paginate-api");
+  }
+  const body = config3.http?.body ?? config3.body;
+  if (body !== void 0 && body !== null) {
+    validateString(body, "body", "paginate-api");
+  }
+  const paginationType = config3.paginationType || "offset";
+  validateEnum(
+    paginationType,
+    ["cursor", "offset", "page", "link_header"],
+    "paginationType",
+    "paginate-api",
+    true
+  );
+  const pageSizeRaw = config3.pageSize;
+  const pageSize = pageSizeRaw !== void 0 && pageSizeRaw !== null ? Number(pageSizeRaw) : 100;
+  if (pageSizeRaw !== void 0 && pageSizeRaw !== null) {
+    validateNumber(pageSizeRaw, "pageSize", "paginate-api");
+  }
+  const paginationConfigInput = config3.paginationConfig || {};
+  if (paginationConfigInput !== void 0 && paginationConfigInput !== null) {
+    validateObject(paginationConfigInput, "paginationConfig", "paginate-api");
+  }
+  const paginationConfig = { ...paginationConfigInput };
+  if (paginationType === "cursor") {
+    paginationConfig.cursorParam = paginationConfig.cursorParam || config3.cursorParam || "cursor";
+    paginationConfig.cursorPath = paginationConfig.cursorPath || config3.cursorPath;
+  } else if (paginationType === "offset") {
+    paginationConfig.offsetParam = paginationConfig.offsetParam || config3.offsetParam || "offset";
+    paginationConfig.limitParam = paginationConfig.limitParam || config3.limitParam || "limit";
+    paginationConfig.limit = paginationConfig.limit ?? pageSize;
+    paginationConfig.totalPath = paginationConfig.totalPath || config3.totalPath;
+  } else if (paginationType === "page") {
+    paginationConfig.pageParam = paginationConfig.pageParam || config3.pageParam || "page";
+    paginationConfig.perPageParam = paginationConfig.perPageParam || config3.perPageParam || "per_page";
+    paginationConfig.perPage = paginationConfig.perPage ?? pageSize;
+    paginationConfig.totalPagesPath = paginationConfig.totalPagesPath || config3.totalPagesPath;
+  }
+  const entitiesPath = config3.entitiesPath || config3.entityPath || "$[*]";
+  validateString(entitiesPath, "entitiesPath", "paginate-api", true);
+  const outputVariable = config3.outputVariable || "entities";
+  validateString(outputVariable, "outputVariable", "paginate-api", true);
+  if (config3.maxPages !== void 0 && config3.maxPages !== null) {
+    validateNumber(config3.maxPages, "maxPages", "paginate-api");
+  }
+  if (config3.maxEntities !== void 0 && config3.maxEntities !== null) {
+    validateNumber(config3.maxEntities, "maxEntities", "paginate-api");
+  }
+  if (config3.requestDelayMs !== void 0 && config3.requestDelayMs !== null) {
+    validateNumber(config3.requestDelayMs, "requestDelayMs", "paginate-api");
+  }
+  if (config3.retryOnRateLimit !== void 0 && config3.retryOnRateLimit !== null) {
+    validateBoolean(config3.retryOnRateLimit, "retryOnRateLimit", "paginate-api");
+  }
+  if (config3.maxRetries !== void 0 && config3.maxRetries !== null) {
+    validateNumber(config3.maxRetries, "maxRetries", "paginate-api");
+  }
+  if (config3.includeMetadata !== void 0 && config3.includeMetadata !== null) {
+    validateBoolean(config3.includeMetadata, "includeMetadata", "paginate-api");
+  }
+  if (config3.streamOutput !== void 0 && config3.streamOutput !== null) {
+    validateBoolean(config3.streamOutput, "streamOutput", "paginate-api");
+  }
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling,
+    "errorHandling",
+    "paginate-api"
+  );
+  return {
+    url: url2,
+    method,
+    headers,
+    body,
+    authType: config3.authType || "none",
+    authConfig: config3.authConfig,
+    paginationType,
+    paginationConfig,
+    pageSize,
+    maxPages: config3.maxPages,
+    offsetParam: config3.offsetParam,
+    limitParam: config3.limitParam,
+    cursorParam: config3.cursorParam,
+    cursorPath: config3.cursorPath,
+    pageParam: config3.pageParam,
+    startPage: config3.startPage,
+    entitiesPath,
+    entityPath: config3.entityPath,
+    entityIdPath: config3.entityIdPath,
+    maxEntities: config3.maxEntities,
+    requestDelayMs: config3.requestDelayMs,
+    retryOnRateLimit: config3.retryOnRateLimit,
+    maxRetries: config3.maxRetries,
+    outputVariable,
+    includeMetadata: config3.includeMetadata,
+    streamOutput: config3.streamOutput,
+    errorHandling,
+    defaultValue: config3.defaultValue
+  };
+}
+function normalizeStoreVectorConfig(config3) {
+  validateConfig(config3, "store-vector");
+  const destination = config3.destination;
+  validateEnum(
+    destination,
+    ["pgvector", "weaviate", "vectorize", "pinecone"],
+    "destination",
+    "store-vector",
+    true
+  );
+  if (config3.vectorsSource) {
+    validateString(config3.vectorsSource, "vectorsSource", "store-vector");
+  }
+  if (config3.inputMode) {
+    validateEnum(config3.inputMode, ["single", "batch"], "inputMode", "store-vector");
+  }
+  if (config3.outputVariable) {
+    validateString(config3.outputVariable, "outputVariable", "store-vector");
+  }
+  if (config3.streamOutput !== void 0 && config3.streamOutput !== null) {
+    validateBoolean(config3.streamOutput, "streamOutput", "store-vector");
+  }
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling,
+    "errorHandling",
+    "store-vector"
+  );
+  const idTemplate = config3.idTemplate;
+  const metadata = config3.metadata;
+  const weaviateConfigInput = config3.weaviateConfig;
+  const vectorizeConfigInput = config3.vectorizeConfig;
+  const pineconeConfig = config3.pineconeConfig;
+  const weaviateConfigId = config3.weaviateConfigId;
+  const weaviateClassName = config3.weaviateClassName;
+  const vectorizeConfigId = config3.vectorizeConfigId;
+  const vectorizeNamespace = config3.vectorizeNamespace;
+  const normalizedWeaviateConfig = weaviateConfigInput || (weaviateConfigId || weaviateClassName || metadata || idTemplate ? {
+    configId: weaviateConfigId,
+    className: weaviateClassName,
+    uuid: idTemplate,
+    properties: metadata
+  } : void 0);
+  const normalizedVectorizeConfig = vectorizeConfigInput || (vectorizeConfigId || vectorizeNamespace || metadata || idTemplate ? {
+    configId: vectorizeConfigId,
+    id: idTemplate,
+    namespace: vectorizeNamespace,
+    metadata
+  } : void 0);
+  return {
+    vectorsSource: config3.vectorsSource,
+    inputMode: config3.inputMode,
+    inputVariable: config3.inputVariable,
+    itemAlias: config3.itemAlias,
+    batchSize: config3.batchSize,
+    destination,
+    weaviateConfig: normalizedWeaviateConfig,
+    vectorizeConfig: normalizedVectorizeConfig,
+    pineconeConfig,
+    weaviateConfigId,
+    weaviateClassName,
+    vectorizeConfigId,
+    vectorizeNamespace,
+    pineconeConfigId: config3.pineconeConfigId,
+    pineconeNamespace: config3.pineconeNamespace,
+    idTemplate,
+    metadata,
+    outputVariable: config3.outputVariable,
+    streamOutput: config3.streamOutput,
+    errorHandling,
+    defaultValue: config3.defaultValue
+  };
+}
+function normalizeToolCallConfig(config3) {
+  validateConfig(config3, "tool-call");
+  validateString(config3.toolId, "toolId", "tool-call", true);
+  validateObject(config3.parameters, "parameters", "tool-call", true);
+  validateString(config3.outputVariable, "outputVariable", "tool-call", true);
+  if (config3.maxRetries !== void 0 && config3.maxRetries !== null) {
+    validateNumber(config3.maxRetries, "maxRetries", "tool-call");
+  }
+  if (config3.timeout !== void 0 && config3.timeout !== null) {
+    validateNumber(config3.timeout, "timeout", "tool-call");
+  }
+  if (config3.onError) {
+    validateEnum(config3.onError, ["fail", "continue", "retry"], "onError", "tool-call");
+  }
+  return {
+    toolId: config3.toolId,
+    parameters: config3.parameters,
+    // Preserve user parameter keys as-is
+    outputVariable: config3.outputVariable,
+    maxRetries: config3.maxRetries,
+    timeout: config3.timeout,
+    onError: config3.onError
+  };
+}
+function normalizeSuccessCriteria(criteria) {
+  if (!criteria) return void 0;
+  validateObject(criteria, "poll.success", "wait-until", true);
+  if (criteria.type) {
+    validateEnum(
+      criteria.type,
+      ["status", "json_path", "body_contains", "expression"],
+      "poll.success.type",
+      "wait-until"
+    );
+  }
+  if (criteria.status !== void 0 && criteria.status !== null) {
+    validateNumber(criteria.status, "poll.success.status", "wait-until");
+  }
+  if (criteria.jsonPath) validateString(criteria.jsonPath, "poll.success.jsonPath", "wait-until");
+  if (criteria.bodyContains)
+    validateString(criteria.bodyContains, "poll.success.bodyContains", "wait-until");
+  if (criteria.expression)
+    validateString(criteria.expression, "poll.success.expression", "wait-until");
+  return {
+    type: criteria.type,
+    status: criteria.status,
+    jsonPath: criteria.jsonPath,
+    expectedValue: criteria.expectedValue,
+    operator: criteria.operator,
+    bodyContains: criteria.bodyContains,
+    expression: criteria.expression
+  };
+}
+function normalizePollConfig(poll) {
+  if (!poll) return void 0;
+  validateObject(poll, "poll", "wait-until", true);
+  if (poll.enabled === false) {
+    const httpConfig = poll.http ? {
+      url: poll.http.url || "",
+      method: poll.http.method,
+      headers: poll.http.headers,
+      body: poll.http.body,
+      timeout: poll.http.timeout
+    } : { url: "" };
+    return {
+      enabled: false,
+      http: httpConfig,
+      auth: poll.auth ? normalizeAuthConfig(poll.auth) : void 0,
+      intervalMs: poll.intervalMs,
+      maxAttempts: poll.maxAttempts,
+      responseType: poll.responseType,
+      success: normalizeSuccessCriteria(poll.success)
+    };
+  }
+  validateObject(poll.http, "poll.http", "wait-until", true);
+  if (poll.intervalMs !== void 0 && poll.intervalMs !== null) {
+    if (typeof poll.intervalMs !== "string") {
+      validateNumber(poll.intervalMs, "poll.intervalMs", "wait-until");
+    }
+  }
+  if (poll.maxAttempts !== void 0 && poll.maxAttempts !== null) {
+    validateNumber(poll.maxAttempts, "poll.maxAttempts", "wait-until");
+  }
+  if (poll.responseType) {
+    validateEnum(poll.responseType, ["json", "text"], "poll.responseType", "wait-until");
+  }
+  if (poll.enabled !== void 0 && poll.enabled !== null) {
+    validateBoolean(poll.enabled, "poll.enabled", "wait-until");
+  }
+  return {
+    enabled: poll.enabled,
+    http: normalizeHttpConfig(poll.http),
+    auth: normalizeAuthConfig(poll.auth),
+    intervalMs: poll.intervalMs,
+    maxAttempts: poll.maxAttempts,
+    responseType: poll.responseType,
+    success: normalizeSuccessCriteria(poll.success)
+  };
+}
+function normalizeWaitUntilConfig(config3) {
+  validateConfig(config3, "wait-until");
+  validateString(config3.outputVariable, "outputVariable", "wait-until", true);
+  if (config3.delayMs === void 0 && !config3.poll) {
+    throw new NormalizationError(
+      `wait-until step requires either 'delayMs' or 'poll' configuration`,
+      "wait-until",
+      "delayMs/poll",
+      "at least one wait mechanism",
+      void 0
+    );
+  }
+  if (config3.delayMs !== void 0 && config3.delayMs !== null) {
+    if (typeof config3.delayMs !== "string") {
+      validateNumber(config3.delayMs, "delayMs", "wait-until");
+    }
+  }
+  if (config3.continueOnTimeout !== void 0 && config3.continueOnTimeout !== null) {
+    validateBoolean(config3.continueOnTimeout, "continueOnTimeout", "wait-until");
+  }
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling,
+    "errorHandling",
+    "wait-until"
+  );
+  return {
+    delayMs: config3.delayMs,
+    poll: normalizePollConfig(config3.poll),
+    continueOnTimeout: config3.continueOnTimeout,
+    errorHandling,
+    defaultValue: config3.defaultValue,
+    outputVariable: config3.outputVariable
+  };
+}
+function normalizeExecuteAgentConfig(config3) {
+  validateConfig(config3, "execute-agent");
+  const agentId = config3.agentId ?? config3.agent_id;
+  validateString(agentId, "agentId", "execute-agent", true);
+  const message = config3.message;
+  validateString(message, "message", "execute-agent", true);
+  const outputVariable = config3.outputVariable ?? config3.output_variable ?? "agent_response";
+  validateString(outputVariable, "outputVariable", "execute-agent");
+  const maxTurns = config3.maxTurns ?? config3.max_turns;
+  if (maxTurns !== void 0 && maxTurns !== null) {
+    validateNumber(maxTurns, "maxTurns", "execute-agent");
+  }
+  if (config3.timeout !== void 0 && config3.timeout !== null) {
+    validateNumber(config3.timeout, "timeout", "execute-agent");
+  }
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling ?? config3.error_handling,
+    "errorHandling",
+    "execute-agent"
+  );
+  return {
+    agentId,
+    message,
+    outputVariable,
+    variables: config3.variables,
+    maxTurns,
+    timeout: config3.timeout,
+    errorHandling,
+    defaultValue: config3.defaultValue ?? config3.default_value
+  };
+}
+function normalizeStoreAssetConfig(config3) {
+  validateConfig(config3, "store-asset");
+  const url2 = config3.url;
+  const content = config3.content;
+  if ((url2 === void 0 || url2 === null) && (content === void 0 || content === null)) {
+    throw new NormalizationError(
+      'store-asset requires either "url" or "content" (base64)',
+      "store-asset",
+      "url",
+      "string",
+      void 0
+    );
+  }
+  if (url2 !== void 0 && url2 !== null && content !== void 0 && content !== null) {
+    throw new NormalizationError(
+      'store-asset accepts exactly one of "url" or "content", not both',
+      "store-asset",
+      "url",
+      "string",
+      typeof url2
+    );
+  }
+  if (url2 !== void 0 && url2 !== null) {
+    validateString(url2, "url", "store-asset", true);
+  }
+  if (content !== void 0 && content !== null) {
+    validateString(content, "content", "store-asset", true);
+  }
+  if (config3.filename !== void 0 && config3.filename !== null) {
+    validateString(config3.filename, "filename", "store-asset");
+  }
+  if (config3.contentType !== void 0 && config3.contentType !== null) {
+    validateString(config3.contentType, "contentType", "store-asset");
+  }
+  if (config3.visibility !== void 0 && config3.visibility !== null) {
+    validateEnum(config3.visibility, ["public", "private"], "visibility", "store-asset");
+  }
+  validateString(config3.outputVariable, "outputVariable", "store-asset", true);
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling,
+    "errorHandling",
+    "store-asset"
+  );
+  return {
+    url: url2,
+    content,
+    filename: config3.filename,
+    contentType: config3.contentType,
+    visibility: config3.visibility,
+    outputVariable: config3.outputVariable,
+    streamOutput: config3.streamOutput,
+    errorHandling,
+    defaultValue: config3.defaultValue
+  };
+}
+function normalizeGeneratePdfConfig(config3) {
+  validateConfig(config3, "generate-pdf");
+  const html = config3.html;
+  const markdown = config3.markdown;
+  if ((html === void 0 || html === null) && (markdown === void 0 || markdown === null)) {
+    throw new NormalizationError(
+      'generate-pdf requires either "html" or "markdown"',
+      "generate-pdf",
+      "html",
+      "string",
+      void 0
+    );
+  }
+  if (html !== void 0 && html !== null && markdown !== void 0 && markdown !== null) {
+    throw new NormalizationError(
+      'generate-pdf accepts exactly one of "html" or "markdown", not both',
+      "generate-pdf",
+      "html",
+      "string",
+      typeof html
+    );
+  }
+  if (html !== void 0 && html !== null) {
+    validateString(html, "html", "generate-pdf", true);
+  }
+  if (markdown !== void 0 && markdown !== null) {
+    validateString(markdown, "markdown", "generate-pdf", true);
+  }
+  if (config3.filename !== void 0 && config3.filename !== null) {
+    validateString(config3.filename, "filename", "generate-pdf");
+  }
+  if (config3.visibility !== void 0 && config3.visibility !== null) {
+    validateEnum(config3.visibility, ["public", "private"], "visibility", "generate-pdf");
+  }
+  if (config3.pdfOptions !== void 0 && config3.pdfOptions !== null) {
+    validateObject(config3.pdfOptions, "pdfOptions", "generate-pdf");
+    const pdfOptions = config3.pdfOptions;
+    if (pdfOptions.format !== void 0 && pdfOptions.format !== null) {
+      validateEnum(pdfOptions.format, ["A4", "Letter"], "pdfOptions.format", "generate-pdf");
+    }
+    if (pdfOptions.landscape !== void 0 && pdfOptions.landscape !== null) {
+      validateBoolean(pdfOptions.landscape, "pdfOptions.landscape", "generate-pdf");
+    }
+  }
+  validateString(config3.outputVariable, "outputVariable", "generate-pdf", true);
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling,
+    "errorHandling",
+    "generate-pdf"
+  );
+  return {
+    html,
+    markdown,
+    filename: config3.filename,
+    visibility: config3.visibility,
+    pdfOptions: config3.pdfOptions,
+    outputVariable: config3.outputVariable,
+    streamOutput: config3.streamOutput,
+    errorHandling,
+    defaultValue: config3.defaultValue
+  };
+}
+function normalizeSaveMemoryConfig(config3) {
+  validateConfig(config3, "save-memory");
+  validateString(config3.profileTemplate, "profileTemplate", "save-memory", true);
+  validateString(config3.contentVariable, "contentVariable", "save-memory", true);
+  if (config3.sessionId !== void 0 && config3.sessionId !== null) {
+    validateString(config3.sessionId, "sessionId", "save-memory");
+  }
+  if (config3.outputVariable !== void 0 && config3.outputVariable !== null) {
+    validateString(config3.outputVariable, "outputVariable", "save-memory");
+  }
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling ?? config3.error_handling,
+    "errorHandling",
+    "save-memory"
+  );
+  return {
+    profileTemplate: config3.profileTemplate,
+    contentVariable: config3.contentVariable,
+    sessionId: config3.sessionId,
+    outputVariable: config3.outputVariable,
+    errorHandling,
+    defaultValue: config3.defaultValue ?? config3.default_value
+  };
+}
+function normalizeRecallMemoryConfig(config3) {
+  validateConfig(config3, "recall-memory");
+  validateString(config3.profileTemplate, "profileTemplate", "recall-memory", true);
+  validateString(config3.queryTemplate, "queryTemplate", "recall-memory", true);
+  validateString(config3.outputVariable, "outputVariable", "recall-memory", true);
+  validateEnum(config3.thinkingLevel, ["low", "medium", "high"], "thinkingLevel", "recall-memory");
+  validateEnum(
+    config3.responseLength,
+    ["short", "medium", "long"],
+    "responseLength",
+    "recall-memory"
+  );
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling ?? config3.error_handling,
+    "errorHandling",
+    "recall-memory"
+  );
+  return {
+    profileTemplate: config3.profileTemplate,
+    queryTemplate: config3.queryTemplate,
+    thinkingLevel: config3.thinkingLevel,
+    responseLength: config3.responseLength,
+    outputVariable: config3.outputVariable,
+    errorHandling,
+    defaultValue: config3.defaultValue ?? config3.default_value
+  };
+}
+function normalizeMemorySummaryConfig(config3) {
+  validateConfig(config3, "memory-summary");
+  validateString(config3.profileTemplate, "profileTemplate", "memory-summary", true);
+  validateString(config3.outputVariable, "outputVariable", "memory-summary", true);
+  if (config3.sessionId !== void 0 && config3.sessionId !== null) {
+    validateString(config3.sessionId, "sessionId", "memory-summary");
+  }
+  const errorHandling = validateAndNormalizeErrorHandling(
+    config3.errorHandling ?? config3.error_handling,
+    "errorHandling",
+    "memory-summary"
+  );
+  return {
+    profileTemplate: config3.profileTemplate,
+    sessionId: config3.sessionId,
+    outputVariable: config3.outputVariable,
+    errorHandling,
+    defaultValue: config3.defaultValue ?? config3.default_value
+  };
+}
+var NAMED_AGENT_REF_PREFIX = "agent:";
+var NAMED_FLOW_REF_PREFIX = "flow:";
+function isNamedRef(value, prefix) {
+  return value.startsWith(prefix) && value.length > prefix.length;
+}
+function parseNamedRef(value, prefix) {
+  if (!isNamedRef(value, prefix)) return null;
+  return { name: value.slice(prefix.length) };
+}
+function parseNamedAgentRef(value) {
+  return parseNamedRef(value, NAMED_AGENT_REF_PREFIX);
+}
+function parseNamedFlowRef(value) {
+  return parseNamedRef(value, NAMED_FLOW_REF_PREFIX);
+}
+function sanitizeCodeToolIdentifier(name) {
+  let safe = name.replace(/[^a-zA-Z0-9_$]/g, "_");
+  if (/^[0-9]/.test(safe)) safe = "_" + safe;
+  return safe;
+}
 var flowStepValidationSchema = external_exports.object({
   // Optional stable client-supplied identifier. Preserved across saves so that
   // `flow_step_results.stepId` references stay valid and dashboard UI state
@@ -17306,6 +19324,1102 @@ var KNOWN_TOOL_KEYS = /* @__PURE__ */ new Set([
   ...Object.keys(CAMEL_CASE_TOOL_KEYS),
   ...Object.keys(SNAKE_CASE_TOOL_KEYS)
 ]);
+var LEGACY_TOOL_KEY_SUGGESTIONS = {
+  builtinTools: "toolIds"
+};
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var NETWORK_ISOLATED_SANDBOX_PROVIDERS = /* @__PURE__ */ new Set(["cloudflare-worker", "quickjs"]);
+var MAX_CONDITIONAL_NESTING_DEPTH = 10;
+var FETCH_CALL_PATTERN = /\bfetch\s*\(/;
+function validateSandboxNetworkAccess(config3, stepIndex, stepRef, buckets) {
+  const rawProvider = typeof config3.sandboxProvider === "string" ? config3.sandboxProvider : "cloudflare-worker";
+  if (!NETWORK_ISOLATED_SANDBOX_PROVIDERS.has(rawProvider)) {
+    return;
+  }
+  const networkAccess = config3.networkAccess;
+  if (networkAccess === "on") {
+    return;
+  }
+  if (isObjectRecord(networkAccess) && Array.isArray(networkAccess.allowedHostnames) && networkAccess.allowedHostnames.length > 0) {
+    return;
+  }
+  const code = typeof config3.script === "string" ? config3.script : "";
+  if (!code || !FETCH_CALL_PATTERN.test(code)) {
+    return;
+  }
+  addIssue(
+    "warning",
+    {
+      code: "SANDBOX_NETWORK_ACCESS_DISABLED",
+      message: "Step uses fetch() but network access is disabled for this sandbox; the request will be blocked at runtime. Set networkAccess to 'on' or an allowedHostnames allowlist, or use the daytona provider.",
+      path: `flowSteps[${stepIndex}].config.networkAccess`,
+      step: stepRef,
+      details: {
+        sandboxProvider: rawProvider,
+        networkAccess: typeof networkAccess === "string" ? networkAccess : "off"
+      }
+    },
+    buckets
+  );
+}
+function validateCodeToolNameCollisions(toolNames, stepRef, code, preSeededCount = 0) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const [i, tool] of toolNames.entries()) {
+    const sanitized = sanitizeCodeToolIdentifier(tool.name);
+    if (i < preSeededCount) {
+      seen.set(sanitized, tool);
+      continue;
+    }
+    const existing = seen.get(sanitized);
+    if (existing) {
+      return {
+        code,
+        message: `Tool names "${existing.name}" and "${tool.name}" both become "${sanitized}" in JavaScript. Rename or remove one before enabling code-mode execution.`,
+        path: tool.path,
+        step: stepRef,
+        details: {
+          firstPath: existing.path,
+          secondPath: tool.path,
+          sanitizedName: sanitized
+        }
+      };
+    }
+    seen.set(sanitized, tool);
+  }
+  return null;
+}
+function formatPath(path18) {
+  return path18.reduce((acc, part) => {
+    if (typeof part === "number") {
+      return `${acc}[${part}]`;
+    }
+    const key = String(part);
+    return acc ? `${acc}.${key}` : key;
+  }, "");
+}
+function compareIssuePath(a, b) {
+  if (!a && !b) return 0;
+  if (!a) return 1;
+  if (!b) return -1;
+  return a.localeCompare(b);
+}
+function sortIssues(issues) {
+  return [...issues].sort((a, b) => {
+    const aStepIndex = a.step?.index ?? Number.MAX_SAFE_INTEGER;
+    const bStepIndex = b.step?.index ?? Number.MAX_SAFE_INTEGER;
+    if (aStepIndex !== bStepIndex) {
+      return aStepIndex - bStepIndex;
+    }
+    const pathCompare = compareIssuePath(a.path, b.path);
+    if (pathCompare !== 0) {
+      return pathCompare;
+    }
+    const codeCompare = a.code.localeCompare(b.code);
+    if (codeCompare !== 0) {
+      return codeCompare;
+    }
+    return a.message.localeCompare(b.message);
+  });
+}
+function addIssue(level, issue2, buckets) {
+  switch (level) {
+    case "error":
+      buckets.errors.push(issue2);
+      return;
+    case "warning":
+      buckets.warnings.push(issue2);
+      return;
+    default:
+      buckets.recommendations.push(issue2);
+  }
+}
+function buildIssueFromZod(issue2, resolvedPath, step) {
+  return {
+    code: "SCHEMA_VALIDATION_FAILED",
+    message: issue2.message,
+    path: resolvedPath,
+    step,
+    details: issue2
+  };
+}
+function conditionalNestingDepth(config3) {
+  let maxDepth = 0;
+  const stack = [{ node: config3, depth: 1 }];
+  while (stack.length > 0) {
+    const { node, depth } = stack.pop();
+    if (depth > maxDepth) maxDepth = depth;
+    if (depth > MAX_CONDITIONAL_NESTING_DEPTH) break;
+    if (!node || typeof node !== "object") continue;
+    const cfg = node;
+    for (const key of ["trueSteps", "falseSteps", "true_steps", "false_steps"]) {
+      const branch = cfg[key];
+      if (!Array.isArray(branch)) continue;
+      for (const s of branch) {
+        if (s && typeof s === "object" && s.type === "conditional") {
+          const nestedCfg = s.config;
+          if (nestedCfg && typeof nestedCfg === "object") {
+            stack.push({ node: nestedCfg, depth: depth + 1 });
+          }
+        }
+      }
+    }
+  }
+  return maxDepth;
+}
+function registerReference(map2, id, reference) {
+  const existing = map2.get(id) || [];
+  existing.push(reference);
+  map2.set(id, existing);
+}
+function collectRuntimeToolNameSelections(toolsConfig, stepIndex, selectedNames) {
+  const runtimeTools = Array.isArray(toolsConfig.runtimeTools) ? toolsConfig.runtimeTools : [];
+  const selections = [];
+  for (const [runtimeToolIndex, runtimeTool] of runtimeTools.entries()) {
+    if (!isObjectRecord(runtimeTool)) {
+      continue;
+    }
+    const name = runtimeTool.name;
+    if (typeof name !== "string") {
+      continue;
+    }
+    if (selectedNames && !selectedNames.has(name)) {
+      continue;
+    }
+    selections.push({
+      name,
+      path: `flowSteps[${stepIndex}].config.tools.runtimeTools[${runtimeToolIndex}].name`
+    });
+  }
+  return selections;
+}
+function collectTransformDataCodeToolNameCheck(toolsConfig, stepIndex, stepRef, pendingChecks) {
+  const toolIds = Array.isArray(toolsConfig.toolIds) ? toolsConfig.toolIds : [];
+  const selectedToolIds = [];
+  const selectedToolNames = [];
+  for (const [toolIdIndex, toolId] of toolIds.entries()) {
+    if (typeof toolId !== "string") {
+      continue;
+    }
+    const path18 = `flowSteps[${stepIndex}].config.tools.toolIds[${toolIdIndex}]`;
+    const named = parseNamedToolRef(toolId);
+    if (named) {
+      selectedToolNames.push({ name: named.name, path: path18 });
+      continue;
+    }
+    const { customToolIds } = separateToolIds([toolId]);
+    if (customToolIds.length === 0) {
+      continue;
+    }
+    selectedToolIds.push({ toolId, path: path18 });
+  }
+  if (selectedToolIds.length > 0 || selectedToolNames.length > 0) {
+    pendingChecks.hasAccountScopedReferences = true;
+    pendingChecks.codeToolNameChecks.push({
+      step: stepRef,
+      collisionCode: "CODE_STEP_TOOL_NAME_COLLISION",
+      runtimeToolNames: collectRuntimeToolNameSelections(toolsConfig, stepIndex),
+      selectedToolIds,
+      selectedToolNames
+    });
+  }
+}
+function collectCodeModeToolNameCheck(toolsConfig, stepIndex, stepRef, pendingChecks) {
+  const codeModeConfig = toolsConfig.codeModeConfig;
+  if (!isObjectRecord(codeModeConfig) || !Array.isArray(codeModeConfig.toolPool)) {
+    return;
+  }
+  const runtimeTools = Array.isArray(toolsConfig.runtimeTools) ? toolsConfig.runtimeTools : [];
+  const runtimeToolNames = /* @__PURE__ */ new Set();
+  for (const runtimeTool of runtimeTools) {
+    if (!isObjectRecord(runtimeTool) || typeof runtimeTool.name !== "string") {
+      continue;
+    }
+    runtimeToolNames.add(runtimeTool.name);
+  }
+  const selectedRuntimeToolNames = /* @__PURE__ */ new Set();
+  const selectedToolIds = [];
+  const selectedToolNames = [];
+  for (const [toolPoolIndex, entry] of codeModeConfig.toolPool.entries()) {
+    if (typeof entry !== "string" || entry.length === 0 || entry.endsWith(":*")) {
+      continue;
+    }
+    const path18 = `flowSteps[${stepIndex}].config.tools.codeModeConfig.toolPool[${toolPoolIndex}]`;
+    const named = parseNamedToolRef(entry);
+    if (named) {
+      selectedToolNames.push({ name: named.name, path: path18 });
+      continue;
+    }
+    if (runtimeToolNames.has(entry)) {
+      selectedRuntimeToolNames.add(entry);
+      continue;
+    }
+    const { customToolIds } = separateToolIds([entry]);
+    if (customToolIds.length === 0) {
+      continue;
+    }
+    selectedToolIds.push({ toolId: entry, path: path18 });
+  }
+  if (selectedToolIds.length > 0 || selectedToolNames.length > 0) {
+    pendingChecks.hasAccountScopedReferences = true;
+    pendingChecks.codeToolNameChecks.push({
+      step: stepRef,
+      collisionCode: "CODE_MODE_TOOL_NAME_COLLISION",
+      runtimeToolNames: collectRuntimeToolNameSelections(
+        toolsConfig,
+        stepIndex,
+        selectedRuntimeToolNames
+      ),
+      selectedToolIds,
+      selectedToolNames
+    });
+  }
+}
+var SINGLE_BRACE_VARIABLE_PATTERN = /(?<!\{)\{([a-zA-Z_][a-zA-Z0-9_.]*)\}(?!\})/g;
+var DOUBLE_BRACE_VARIABLE_PATTERN = TEMPLATE_EXPRESSION_PATTERN;
+var TEMPLATE_STRING_FIELDS = /* @__PURE__ */ new Set([
+  "text",
+  "userPrompt",
+  "systemPrompt",
+  "url",
+  "body",
+  "query",
+  "message",
+  "valueTemplate",
+  "value",
+  "subject",
+  "html",
+  "from",
+  "to",
+  "cc",
+  "bcc",
+  "replyTo",
+  "nameTemplate",
+  "condition",
+  "script",
+  "requestTemplate"
+]);
+var NON_FLOW_VARIABLE_SUBTREE_KEYS = /* @__PURE__ */ new Set(["tools"]);
+function extractTemplateStrings(config3, path18 = []) {
+  const results = [];
+  if (typeof config3 === "string") {
+    const fieldName = path18[path18.length - 1];
+    const parentFieldName = path18.length >= 2 ? path18[path18.length - 2] : void 0;
+    if (fieldName && TEMPLATE_STRING_FIELDS.has(fieldName) || parentFieldName && TEMPLATE_STRING_FIELDS.has(parentFieldName)) {
+      results.push({ value: config3, fieldPath: path18.join(".") });
+    }
+    return results;
+  }
+  if (Array.isArray(config3)) {
+    for (const [index, item] of config3.entries()) {
+      results.push(...extractTemplateStrings(item, [...path18, String(index)]));
+    }
+    return results;
+  }
+  if (isObjectRecord(config3)) {
+    for (const [key, val] of Object.entries(config3)) {
+      if (NON_FLOW_VARIABLE_SUBTREE_KEYS.has(key)) continue;
+      if (typeof val === "string" && TEMPLATE_STRING_FIELDS.has(key)) {
+        results.push({ value: val, fieldPath: [...path18, key].join(".") });
+      } else if (typeof val === "object" && val !== null) {
+        results.push(...extractTemplateStrings(val, [...path18, key]));
+      }
+    }
+  }
+  return results;
+}
+function detectMalformedVariableReferences(config3) {
+  const malformed = [];
+  const templateStrings = extractTemplateStrings(config3);
+  for (const { value, fieldPath } of templateStrings) {
+    let match;
+    const pattern = new RegExp(SINGLE_BRACE_VARIABLE_PATTERN.source, "g");
+    while ((match = pattern.exec(value)) !== null) {
+      const varName = match[1];
+      if (!varName) continue;
+      const doublebraceForm = `{{${varName}}}`;
+      if (value.includes(doublebraceForm)) continue;
+      malformed.push({ variable: varName, fieldPath });
+    }
+  }
+  return malformed;
+}
+function extractVariableReferences(config3) {
+  const references = [];
+  const templateStrings = extractTemplateStrings(config3);
+  for (const { value, fieldPath } of templateStrings) {
+    const pattern = new RegExp(DOUBLE_BRACE_VARIABLE_PATTERN.source, "g");
+    let match;
+    while ((match = pattern.exec(value)) !== null) {
+      const expr = match[1];
+      if (!expr) continue;
+      for (const path18 of extractTemplateExpressionPaths(expr)) {
+        references.push({ variable: path18, fieldPath });
+      }
+    }
+  }
+  return references;
+}
+function getStepOutputVariable(step) {
+  if (!isObjectRecord(step.config)) return null;
+  if (typeof step.config.outputVariable === "string" && step.config.outputVariable.length > 0) {
+    return step.config.outputVariable;
+  }
+  if (step.type === "set-variable" && typeof step.config.variableName === "string" && step.config.variableName.length > 0) {
+    return step.config.variableName;
+  }
+  return null;
+}
+function collectDeclaredFlowInputs(flowSteps, declaredFlowInputs) {
+  const declared = /* @__PURE__ */ new Set();
+  for (const key of declaredFlowInputs ?? []) {
+    if (typeof key === "string" && key) declared.add(key);
+  }
+  for (const step of flowSteps) {
+    const config3 = step.config;
+    const inputVariables = config3?.inputVariables;
+    if (Array.isArray(inputVariables)) {
+      for (const name of inputVariables) {
+        if (typeof name === "string" && name) declared.add(name);
+      }
+    }
+  }
+  return declared;
+}
+function validateVariableReferences(flowSteps, buckets, skipStepIndices, declaredFlowInputs) {
+  const declaredVariables = collectDeclaredFlowInputs(flowSteps, declaredFlowInputs);
+  for (const [stepIndex, step] of flowSteps.entries()) {
+    if (skipStepIndices?.has(stepIndex)) continue;
+    const stepRef = {
+      index: stepIndex,
+      name: step.name,
+      type: step.type
+    };
+    const malformed = detectMalformedVariableReferences(step.config);
+    for (const { variable, fieldPath } of malformed) {
+      addIssue(
+        "warning",
+        {
+          code: "MALFORMED_VARIABLE_REFERENCE",
+          message: `Possible malformed variable reference "{${variable}}" \u2014 use "{{${variable}}}" for template variable substitution.`,
+          path: `flowSteps[${stepIndex}].config.${fieldPath}`,
+          step: stepRef,
+          details: { variable, suggestion: `{{${variable}}}` }
+        },
+        buckets
+      );
+    }
+    const references = extractVariableReferences(step.config);
+    for (const { variable, fieldPath } of references) {
+      const classification = classifyVariableReference(variable);
+      if (classification.namespace === "system" || classification.namespace === "secret") {
+        continue;
+      }
+      if (classification.namespace === "unknown") {
+        addIssue(
+          "warning",
+          {
+            code: "UNKNOWN_VARIABLE_NAMESPACE",
+            message: `Variable "{{${variable}}}" uses an unrecognized namespace prefix. Recognized prefixes are "flow:" (a flow input) and "secret:" (a configured secret). Use a known prefix or a plain variable name.`,
+            path: `flowSteps[${stepIndex}].config.${fieldPath}`,
+            step: stepRef,
+            details: { variable }
+          },
+          buckets
+        );
+        continue;
+      }
+      const baseName = classification.baseName;
+      const rootVariable = baseName.split(".")[0] || "";
+      if (!declaredVariables.has(rootVariable) && !declaredVariables.has(baseName)) {
+        addIssue(
+          "warning",
+          {
+            code: "UNDECLARED_VARIABLE_REFERENCE",
+            message: `Variable "{{${variable}}}" is referenced but no earlier step declares an output variable "${rootVariable}". Check that a previous step sets outputVariable to "${rootVariable}", or declare "${rootVariable}" as a flow input.`,
+            path: `flowSteps[${stepIndex}].config.${fieldPath}`,
+            step: stepRef,
+            details: {
+              variable,
+              availableVariables: [...declaredVariables]
+            }
+          },
+          buckets
+        );
+      }
+    }
+    if (step.enabled !== false) {
+      const outputVar = getStepOutputVariable(step);
+      if (outputVar) {
+        declaredVariables.add(outputVar);
+      }
+    }
+  }
+}
+function promptResponseFormatIsNonJson(responseFormat) {
+  if (typeof responseFormat !== "string") return true;
+  return responseFormat.trim().toLowerCase() !== "json";
+}
+function validateUpsertRecordSourceShape(flowSteps, buckets) {
+  const stringPromptOutputs = /* @__PURE__ */ new Map();
+  for (const [stepIndex, step] of flowSteps.entries()) {
+    if (step.enabled === false) continue;
+    if (!isObjectRecord(step.config)) continue;
+    const config3 = step.config;
+    if (step.type === "upsert-record") {
+      const inputMode = typeof config3.inputMode === "string" ? config3.inputMode : "single";
+      const sourceVariable = typeof config3.sourceVariable === "string" ? config3.sourceVariable : "";
+      const hasContentField = typeof config3.contentField === "string" && config3.contentField.length > 0;
+      if (inputMode !== "batch" && sourceVariable && !hasContentField) {
+        const origin = stringPromptOutputs.get(sourceVariable);
+        if (origin) {
+          addIssue(
+            "warning",
+            {
+              code: "UPSERT_RECORD_SOURCE_NOT_JSON",
+              message: `Source variable "${sourceVariable}" is set by prompt step "${origin.name}" (responseFormat "${origin.responseFormat}"), which outputs a string, but the record metadata column requires a JSON object. This will fail at runtime. Either: (1) set that prompt's responseFormat to "json", (2) add a transform-data step to wrap the string, or (3) set contentField on this upsert-record step to auto-wrap the string as { [contentField]: content }.`,
+              path: `flowSteps[${stepIndex}].config.sourceVariable`,
+              step: { index: stepIndex, name: step.name, type: step.type },
+              details: {
+                sourceVariable,
+                originStepIndex: origin.index,
+                originStepName: origin.name,
+                responseFormat: origin.responseFormat
+              }
+            },
+            buckets
+          );
+        }
+      }
+    }
+    const outputVar = getStepOutputVariable(step);
+    if (outputVar) {
+      if (step.type === "prompt" && promptResponseFormatIsNonJson(config3.responseFormat)) {
+        const responseFormat = typeof config3.responseFormat === "string" ? config3.responseFormat : "default";
+        stringPromptOutputs.set(outputVar, { index: stepIndex, name: step.name, responseFormat });
+      } else {
+        stringPromptOutputs.delete(outputVar);
+      }
+    }
+  }
+}
+function collectAccountScopedReferences(step, stepIndex, pendingChecks) {
+  const stepRef = {
+    index: stepIndex,
+    name: step.name,
+    type: step.type
+  };
+  if (!isObjectRecord(step.config)) {
+    return;
+  }
+  if (step.type === "execute-agent") {
+    const agentId = step.config.agentId;
+    if (typeof agentId === "string" && !agentId.includes("{{")) {
+      const path18 = `flowSteps[${stepIndex}].config.agentId`;
+      registerAgentReference(agentId, path18, stepRef, pendingChecks);
+    }
+    return;
+  }
+  if (step.type === "tool-call") {
+    const toolId = step.config.toolId;
+    if (typeof toolId === "string") {
+      const path18 = `flowSteps[${stepIndex}].config.toolId`;
+      const named = parseNamedToolRef(toolId);
+      if (named) {
+        pendingChecks.hasAccountScopedReferences = true;
+        registerReference(pendingChecks.toolReferencesByName, named.name, { path: path18, step: stepRef });
+      } else {
+        const { customToolIds } = separateToolIds([toolId]);
+        if (customToolIds.length > 0) {
+          pendingChecks.hasAccountScopedReferences = true;
+          registerReference(pendingChecks.toolReferencesById, toolId, { path: path18, step: stepRef });
+        }
+      }
+    }
+    return;
+  }
+  if (step.type !== "prompt" && step.type !== "transform-data") {
+    return;
+  }
+  const toolsConfig = step.config.tools;
+  if (!isObjectRecord(toolsConfig)) {
+    return;
+  }
+  const toolIds = toolsConfig.toolIds;
+  if (Array.isArray(toolIds)) {
+    for (const [toolIdIndex, toolId] of toolIds.entries()) {
+      if (typeof toolId !== "string") {
+        continue;
+      }
+      const path18 = `flowSteps[${stepIndex}].config.tools.toolIds[${toolIdIndex}]`;
+      const named = parseNamedToolRef(toolId);
+      if (named) {
+        pendingChecks.hasAccountScopedReferences = true;
+        registerReference(pendingChecks.toolReferencesByName, named.name, { path: path18, step: stepRef });
+        continue;
+      }
+      const { customToolIds } = separateToolIds([toolId]);
+      if (customToolIds.length > 0) {
+        pendingChecks.hasAccountScopedReferences = true;
+        registerReference(pendingChecks.toolReferencesById, toolId, { path: path18, step: stepRef });
+      }
+    }
+  }
+  if (step.type === "transform-data") {
+    collectTransformDataCodeToolNameCheck(toolsConfig, stepIndex, stepRef, pendingChecks);
+  } else {
+    collectCodeModeToolNameCheck(toolsConfig, stepIndex, stepRef, pendingChecks);
+  }
+  const runtimeTools = toolsConfig.runtimeTools;
+  if (!Array.isArray(runtimeTools)) {
+    return;
+  }
+  for (const [runtimeToolIndex, runtimeTool] of runtimeTools.entries()) {
+    if (!isObjectRecord(runtimeTool)) {
+      continue;
+    }
+    const runtimeConfig = runtimeTool.config;
+    if (!isObjectRecord(runtimeConfig)) {
+      continue;
+    }
+    const basePath = `flowSteps[${stepIndex}].config.tools.runtimeTools[${runtimeToolIndex}].config`;
+    if (runtimeTool.toolType === "flow") {
+      const flowId = runtimeConfig.flowId;
+      if (typeof flowId === "string") {
+        registerFlowReference(flowId, `${basePath}.flowId`, stepRef, pendingChecks);
+      }
+      continue;
+    }
+    if (runtimeTool.toolType === "subagent") {
+      const agentId = runtimeConfig.agentId;
+      if (typeof agentId === "string" && !agentId.includes("{{")) {
+        registerAgentReference(agentId, `${basePath}.agentId`, stepRef, pendingChecks);
+      }
+      continue;
+    }
+  }
+}
+function registerAgentReference(agentId, path18, stepRef, pendingChecks) {
+  const named = parseNamedAgentRef(agentId);
+  pendingChecks.hasAccountScopedReferences = true;
+  if (named) {
+    registerReference(pendingChecks.agentReferencesByName, named.name, { path: path18, step: stepRef });
+  } else {
+    registerReference(pendingChecks.agentReferencesById, agentId, { path: path18, step: stepRef });
+  }
+}
+function registerFlowReference(flowId, path18, stepRef, pendingChecks) {
+  const named = parseNamedFlowRef(flowId);
+  pendingChecks.hasAccountScopedReferences = true;
+  if (named) {
+    registerReference(pendingChecks.flowReferencesByName, named.name, { path: path18, step: stepRef });
+  } else {
+    registerReference(pendingChecks.flowReferencesById, flowId, { path: path18, step: stepRef });
+  }
+}
+function validateSubagentConfig(value, stepTools, stepIndex, stepRef) {
+  const basePath = `flowSteps[${stepIndex}].config.tools.subagentConfig`;
+  if (!isObjectRecord(value)) {
+    return {
+      code: "SUBAGENT_CONFIG_INVALID",
+      message: "subagentConfig must be an object.",
+      path: basePath,
+      step: stepRef
+    };
+  }
+  const cfg = value;
+  if (!Array.isArray(cfg.toolPool)) {
+    return {
+      code: "SUBAGENT_CONFIG_INVALID",
+      message: "subagentConfig.toolPool must be an array of tool IDs (wildcards allowed).",
+      path: `${basePath}.toolPool`,
+      step: stepRef
+    };
+  }
+  const parentToolIds = new Set(
+    Array.isArray(stepTools.toolIds) ? stepTools.toolIds.filter((x2) => typeof x2 === "string") : []
+  );
+  const parentRuntimeToolNames = new Set(
+    Array.isArray(stepTools.runtimeTools) ? stepTools.runtimeTools.map((t) => t.name).filter((n) => typeof n === "string") : []
+  );
+  for (const entry of cfg.toolPool) {
+    if (typeof entry !== "string" || entry.length === 0) {
+      return {
+        code: "SUBAGENT_CONFIG_INVALID",
+        message: "subagentConfig.toolPool entries must be non-empty strings.",
+        path: `${basePath}.toolPool`,
+        step: stepRef
+      };
+    }
+    const isWildcard2 = entry.endsWith(":*");
+    if (isWildcard2) continue;
+    if (!parentToolIds.has(entry) && !parentRuntimeToolNames.has(entry)) {
+      return {
+        code: "SUBAGENT_CONFIG_ESCALATION",
+        message: `subagentConfig.toolPool entry "${entry}" is not granted to the parent step. Every pool entry must be a wildcard (\`foo:*\`) or appear in the parent step's toolIds or runtimeTools \u2014 otherwise the spawned subagent cannot actually call it.`,
+        path: `${basePath}.toolPool`,
+        step: stepRef
+      };
+    }
+  }
+  if (cfg.defaultMaxTurns !== void 0) {
+    const n = cfg.defaultMaxTurns;
+    if (typeof n !== "number" || !Number.isInteger(n) || n < 1) {
+      return {
+        code: "SUBAGENT_CONFIG_INVALID",
+        message: "subagentConfig.defaultMaxTurns must be a positive integer.",
+        path: `${basePath}.defaultMaxTurns`,
+        step: stepRef
+      };
+    }
+  }
+  if (cfg.maxTurnsLimit !== void 0) {
+    const n = cfg.maxTurnsLimit;
+    if (typeof n !== "number" || !Number.isInteger(n) || n < 1) {
+      return {
+        code: "SUBAGENT_CONFIG_INVALID",
+        message: "subagentConfig.maxTurnsLimit must be a positive integer.",
+        path: `${basePath}.maxTurnsLimit`,
+        step: stepRef
+      };
+    }
+  }
+  if (cfg.maxSpawnsPerRun !== void 0) {
+    const n = cfg.maxSpawnsPerRun;
+    if (typeof n !== "number" || !Number.isInteger(n) || n < 1) {
+      return {
+        code: "SUBAGENT_CONFIG_INVALID",
+        message: "subagentConfig.maxSpawnsPerRun must be a positive integer.",
+        path: `${basePath}.maxSpawnsPerRun`,
+        step: stepRef
+      };
+    }
+  }
+  return null;
+}
+function validateCodeModeConfig(value, stepTools, stepIndex, stepRef) {
+  const basePath = `flowSteps[${stepIndex}].config.tools.codeModeConfig`;
+  if (!isObjectRecord(value)) {
+    return {
+      code: "CODE_MODE_CONFIG_INVALID",
+      message: "codeModeConfig must be an object.",
+      path: basePath,
+      step: stepRef
+    };
+  }
+  const cfg = value;
+  if (!Array.isArray(cfg.toolPool)) {
+    return {
+      code: "CODE_MODE_CONFIG_INVALID",
+      message: "codeModeConfig.toolPool must be an array of tool IDs (wildcards allowed).",
+      path: `${basePath}.toolPool`,
+      step: stepRef
+    };
+  }
+  const parentToolIds = new Set(
+    Array.isArray(stepTools.toolIds) ? stepTools.toolIds.filter((x2) => typeof x2 === "string") : []
+  );
+  const parentRuntimeTools = Array.isArray(stepTools.runtimeTools) ? stepTools.runtimeTools : [];
+  const parentRuntimeToolNames = new Set(
+    parentRuntimeTools.map((t) => t.name).filter((n) => typeof n === "string")
+  );
+  const runtimeToolByName = new Map(
+    parentRuntimeTools.filter((t) => typeof t.name === "string").map((t) => [t.name, t])
+  );
+  const selectedRuntimeToolNames = [];
+  for (const entry of cfg.toolPool) {
+    if (typeof entry !== "string" || entry.length === 0) {
+      return {
+        code: "CODE_MODE_CONFIG_INVALID",
+        message: "codeModeConfig.toolPool entries must be non-empty strings.",
+        path: `${basePath}.toolPool`,
+        step: stepRef
+      };
+    }
+    const isWildcard2 = entry.endsWith(":*");
+    if (isWildcard2) continue;
+    const runtimeTool = runtimeToolByName.get(entry);
+    if (runtimeTool) {
+      if (runtimeTool.toolType === "local") {
+        return {
+          code: "CODE_MODE_CONFIG_INVALID",
+          message: `codeModeConfig.toolPool entry "${entry}" is a local tool. Code mode cannot pause for client-side local tool callbacks.`,
+          path: `${basePath}.toolPool`,
+          step: stepRef
+        };
+      }
+      selectedRuntimeToolNames.push({
+        name: entry,
+        path: `${basePath}.toolPool`
+      });
+    }
+    if (!parentToolIds.has(entry) && !parentRuntimeToolNames.has(entry)) {
+      return {
+        code: "CODE_MODE_CONFIG_ESCALATION",
+        message: `codeModeConfig.toolPool entry "${entry}" is not granted to the parent step. Every pool entry must be a wildcard (\`foo:*\`) or appear in the parent step's toolIds or runtimeTools \u2014 otherwise the sandbox code cannot actually call it.`,
+        path: `${basePath}.toolPool`,
+        step: stepRef
+      };
+    }
+  }
+  const collision = validateCodeToolNameCollisions(
+    selectedRuntimeToolNames,
+    stepRef,
+    "CODE_MODE_TOOL_NAME_COLLISION"
+  );
+  if (collision) {
+    return collision;
+  }
+  if (cfg.timeoutMs !== void 0) {
+    const n = cfg.timeoutMs;
+    if (typeof n !== "number" || !Number.isFinite(n) || n < 1e3 || n > 6e5) {
+      return {
+        code: "CODE_MODE_CONFIG_INVALID",
+        message: "codeModeConfig.timeoutMs must be a number between 1000 and 600000.",
+        path: `${basePath}.timeoutMs`,
+        step: stepRef
+      };
+    }
+  }
+  return null;
+}
+function validateTransformDataCodeTools(toolsConfig, stepIndex, stepRef, buckets) {
+  const runtimeTools = Array.isArray(toolsConfig.runtimeTools) ? toolsConfig.runtimeTools : [];
+  const runtimeToolNames = [];
+  for (const [runtimeToolIndex, runtimeTool] of runtimeTools.entries()) {
+    if (!isObjectRecord(runtimeTool)) {
+      continue;
+    }
+    const basePath = `flowSteps[${stepIndex}].config.tools.runtimeTools[${runtimeToolIndex}]`;
+    const name = runtimeTool.name;
+    if (typeof name === "string") {
+      runtimeToolNames.push({ name, path: `${basePath}.name` });
+    }
+    if (runtimeTool.toolType === "local") {
+      addIssue(
+        "error",
+        {
+          code: "CODE_STEP_LOCAL_TOOL_UNSUPPORTED",
+          message: "Transform-data code steps do not support local tools because code execution cannot pause for client-side callbacks.",
+          path: `${basePath}.toolType`,
+          step: stepRef
+        },
+        buckets
+      );
+    }
+  }
+  const collision = validateCodeToolNameCollisions(
+    runtimeToolNames,
+    stepRef,
+    "CODE_STEP_TOOL_NAME_COLLISION"
+  );
+  if (collision) {
+    addIssue("error", collision, buckets);
+  }
+}
+function validateErrorHandlingTriggers(errorHandling, stepIndex, stepRef, buckets) {
+  if (!isObjectRecord(errorHandling) || !Array.isArray(errorHandling.triggers)) {
+    return;
+  }
+  for (const [triggerIndex, trigger] of errorHandling.triggers.entries()) {
+    if (!isObjectRecord(trigger) || trigger.type !== "slow") continue;
+    const afterMs = trigger.afterMs;
+    if (typeof afterMs !== "number" || !Number.isFinite(afterMs) || afterMs <= 0) {
+      addIssue(
+        "error",
+        {
+          code: "SLOW_TRIGGER_INVALID_AFTER_MS",
+          message: 'A "slow" fallback trigger requires a positive "afterMs" (the total-duration cap in milliseconds) before it can fire.',
+          path: `flowSteps[${stepIndex}].config.errorHandling.triggers[${triggerIndex}].afterMs`,
+          step: stepRef,
+          details: { afterMs }
+        },
+        buckets
+      );
+    }
+  }
+}
+function collectFlowStructureIssues(flowData, deps, buckets) {
+  const pendingChecks = {
+    hasAccountScopedReferences: false,
+    toolReferencesById: /* @__PURE__ */ new Map(),
+    toolReferencesByName: /* @__PURE__ */ new Map(),
+    flowReferencesById: /* @__PURE__ */ new Map(),
+    agentReferencesById: /* @__PURE__ */ new Map(),
+    agentReferencesByName: /* @__PURE__ */ new Map(),
+    flowReferencesByName: /* @__PURE__ */ new Map(),
+    codeToolNameChecks: []
+  };
+  const orderToStepIndexes = /* @__PURE__ */ new Map();
+  const normalizedOrders = flowData.flowSteps.map((step, index) => step.order ?? index);
+  for (const [index, order] of normalizedOrders.entries()) {
+    const existing = orderToStepIndexes.get(order) || [];
+    existing.push(index);
+    orderToStepIndexes.set(order, existing);
+  }
+  for (const [order, indexes] of orderToStepIndexes.entries()) {
+    if (indexes.length <= 1) {
+      continue;
+    }
+    addIssue(
+      "warning",
+      {
+        code: "DUPLICATE_STEP_ORDER",
+        message: `Multiple steps share order "${order}". Execution order may be ambiguous.`,
+        details: { order, stepIndexes: indexes }
+      },
+      buckets
+    );
+  }
+  const idToStepIndexes = /* @__PURE__ */ new Map();
+  for (const [index, step] of flowData.flowSteps.entries()) {
+    if (typeof step.id !== "string" || step.id.length === 0) continue;
+    const existing = idToStepIndexes.get(step.id) || [];
+    existing.push(index);
+    idToStepIndexes.set(step.id, existing);
+  }
+  for (const [id, indexes] of idToStepIndexes.entries()) {
+    if (indexes.length <= 1) continue;
+    addIssue(
+      "error",
+      {
+        code: "DUPLICATE_STEP_ID",
+        message: `Multiple steps share id "${id}". Step ids must be unique within a flow.`,
+        details: { id, stepIndexes: indexes }
+      },
+      buckets
+    );
+  }
+  const enabledSteps = flowData.flowSteps.filter((step) => step.enabled !== false);
+  if (enabledSteps.length === 0) {
+    addIssue(
+      "warning",
+      {
+        code: "NO_ENABLED_STEPS",
+        message: "This flow has no enabled steps."
+      },
+      buckets
+    );
+  }
+  if (!enabledSteps.some((step) => step.type === "prompt")) {
+    addIssue(
+      "recommendation",
+      {
+        code: "NO_PROMPT_STEPS",
+        message: "No enabled prompt steps were found. Most flows require at least one prompt step."
+      },
+      buckets
+    );
+  }
+  const conditionalStepsExceedingDepth = /* @__PURE__ */ new Set();
+  const declaredVariables = /* @__PURE__ */ new Set();
+  for (const [stepIndex, step] of flowData.flowSteps.entries()) {
+    const stepRef = {
+      index: stepIndex,
+      name: step.name,
+      type: step.type
+    };
+    if (step.type === "conditional" && conditionalNestingDepth(step.config) > MAX_CONDITIONAL_NESTING_DEPTH) {
+      conditionalStepsExceedingDepth.add(stepIndex);
+      addIssue(
+        "error",
+        {
+          code: "CONDITIONAL_NESTING_TOO_DEEP",
+          message: `Conditional steps may nest at most ${MAX_CONDITIONAL_NESTING_DEPTH} levels deep.`,
+          path: `flowSteps[${stepIndex}].config`,
+          step: stepRef
+        },
+        buckets
+      );
+      continue;
+    }
+    const configSchema = deps.configSchemas?.[step.type];
+    if (configSchema) {
+      const schemaResult = configSchema.safeParse(step.config);
+      if (!schemaResult.success) {
+        for (const issue2 of schemaResult.error.issues) {
+          const issuePath = issue2.path.length > 0 ? `flowSteps[${stepIndex}].config.${formatPath(issue2.path)}` : `flowSteps[${stepIndex}].config`;
+          addIssue("error", buildIssueFromZod(issue2, issuePath, stepRef), buckets);
+        }
+      }
+    }
+    if (isObjectRecord(step.config)) {
+      validateErrorHandlingTriggers(step.config.errorHandling, stepIndex, stepRef, buckets);
+    }
+    if (isObjectRecord(step.config) && isObjectRecord(step.config.tools)) {
+      for (const key of Object.keys(step.config.tools)) {
+        if (KNOWN_TOOL_KEYS.has(key)) continue;
+        const suggestion = LEGACY_TOOL_KEY_SUGGESTIONS[key];
+        addIssue(
+          "warning",
+          {
+            code: "UNKNOWN_PROMPT_TOOLS_FIELD",
+            message: suggestion ? `Unknown field "${key}" under config.tools \u2014 did you mean "${suggestion}"? The runtime will ignore this value.` : `Unknown field "${key}" under config.tools \u2014 the runtime will ignore it. Expected keys: ${[...KNOWN_TOOL_KEYS].join(", ")}.`,
+            path: `flowSteps[${stepIndex}].config.tools.${key}`,
+            step: stepRef,
+            details: suggestion ? { field: key, suggestion } : { field: key }
+          },
+          buckets
+        );
+      }
+      if (deps.validateRuntimeTools) {
+        const runtimeToolsValidation = deps.validateRuntimeTools(step.config.tools);
+        if (!runtimeToolsValidation.valid) {
+          addIssue(
+            "error",
+            {
+              code: "RUNTIME_TOOLS_INVALID",
+              message: runtimeToolsValidation.error || "Invalid runtime tools configuration",
+              path: `flowSteps[${stepIndex}].config.tools`,
+              step: stepRef
+            },
+            buckets
+          );
+        }
+      }
+      if (step.type === "transform-data") {
+        validateTransformDataCodeTools(step.config.tools, stepIndex, stepRef, buckets);
+      }
+      const subagentCfg = step.config.tools.subagentConfig;
+      if (subagentCfg !== void 0) {
+        const issue2 = validateSubagentConfig(subagentCfg, step.config.tools, stepIndex, stepRef);
+        if (issue2) addIssue("error", issue2, buckets);
+      }
+      const codeModeCfg = step.config.tools.codeModeConfig;
+      if (codeModeCfg !== void 0) {
+        const issue2 = validateCodeModeConfig(codeModeCfg, step.config.tools, stepIndex, stepRef);
+        if (issue2) addIssue("error", issue2, buckets);
+      }
+    }
+    if (step.type !== "prompt") {
+      try {
+        normalizeContextStep(
+          {
+            id: `step_validation_${stepIndex}`,
+            type: step.type,
+            name: step.name,
+            order: step.order ?? stepIndex,
+            enabled: step.enabled ?? true,
+            config: step.config
+          },
+          {
+            managedSendFromDomain: deps.managedSendFromDomain
+          }
+        );
+      } catch (error51) {
+        const normalizationError = error51 instanceof NormalizationError ? error51 : null;
+        const fallbackMessage = error51 instanceof Error ? error51.message : String(error51);
+        const fieldName = normalizationError?.fieldName;
+        addIssue(
+          "error",
+          {
+            code: "CONTEXT_STEP_INVALID",
+            message: normalizationError?.message || fallbackMessage,
+            path: fieldName ? `flowSteps[${stepIndex}].config.${fieldName}` : `flowSteps[${stepIndex}].config`,
+            step: stepRef
+          },
+          buckets
+        );
+      }
+    }
+    if (step.type === "transform-data" && step.enabled !== false && isObjectRecord(step.config)) {
+      const config3 = step.config;
+      const sandboxProvider = config3.sandboxProvider || "cloudflare-worker";
+      const resolvedProvider = sandboxProvider === "cloudflare-sandbox" ? "runtype-sandbox" : sandboxProvider;
+      validateSandboxNetworkAccess(config3, stepIndex, stepRef, buckets);
+      if (resolvedProvider === "runtype-sandbox" && !config3.language) {
+        addIssue(
+          "warning",
+          {
+            code: "MISSING_LANGUAGE",
+            message: 'language is recommended when sandboxProvider is "runtype-sandbox" \u2014 defaults to "javascript" but you should specify "javascript", "typescript", or "python" explicitly',
+            path: `flowSteps[${stepIndex}].config.language`,
+            step: stepRef
+          },
+          buckets
+        );
+      }
+      if (deps.validateScript && config3.inputMode !== "variable" && typeof config3.script === "string" && config3.script.trim()) {
+        const codeResult = deps.validateScript(
+          config3.script,
+          {
+            sandboxProvider,
+            language: config3.language,
+            availableVariables: [...declaredVariables]
+          },
+          { stepIndex }
+        );
+        for (const issue2 of codeResult.issues) {
+          const location = issue2.line ? ` (line ${issue2.line}, column ${issue2.column})` : "";
+          const issueCode = issue2.code === "SYNTAX_ERROR" ? "CODE_SYNTAX_ERROR" : `CODE_${issue2.code}`;
+          addIssue(
+            issue2.severity,
+            {
+              code: issueCode,
+              message: `${issue2.message}${location}`,
+              path: `flowSteps[${stepIndex}].config.script`,
+              step: stepRef,
+              details: {
+                language: config3.language || "javascript",
+                sandboxProvider,
+                ...issue2.line !== void 0 ? { line: issue2.line } : {},
+                ...issue2.column !== void 0 ? { column: issue2.column } : {}
+              }
+            },
+            buckets
+          );
+        }
+      }
+    }
+    collectAccountScopedReferences(step, stepIndex, pendingChecks);
+    if (step.enabled !== false) {
+      const outputVar = getStepOutputVariable(step);
+      if (outputVar) declaredVariables.add(outputVar);
+    }
+  }
+  validateVariableReferences(
+    flowData.flowSteps,
+    buckets,
+    conditionalStepsExceedingDepth,
+    deps.declaredFlowInputs
+  );
+  validateUpsertRecordSourceShape(flowData.flowSteps, buckets);
+  return { pendingChecks };
+}
+function validateFlowStructure(flowData, deps = {}) {
+  const buckets = { errors: [], warnings: [], recommendations: [] };
+  collectFlowStructureIssues(flowData, deps, buckets);
+  const errors = sortIssues(buckets.errors);
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings: sortIssues(buckets.warnings),
+    recommendations: sortIssues(buckets.recommendations),
+    context: {
+      authenticated: false,
+      accountChecksPerformed: false,
+      accountChecksSkipped: false
+    }
+  };
+}
+function parseCreateFlowValidationInput(payload) {
+  const parsed = createFlowValidationSchema.safeParse(payload);
+  if (parsed.success) {
+    return {
+      success: true,
+      data: parsed.data
+    };
+  }
+  return {
+    success: false,
+    errors: sortIssues(
+      parsed.error.issues.map(
+        (issue2) => buildIssueFromZod(issue2, formatPath(issue2.path) || "root", void 0)
+      )
+    )
+  };
+}
 var SERIALIZED_HELPERS_SOURCE = `
 // Transform helper functions (from packages/shared/src/transform-helpers.ts)
 const helpers = (function createHelpers() {
@@ -36737,6 +39851,7 @@ function mergeResults(...results) {
   merged.valid = merged.errors.length === 0;
   return merged;
 }
+var NAMESPACE_VARIABLE_CODES = /* @__PURE__ */ new Set(["UNDECLARED_VARIABLE_REFERENCE", "UNKNOWN_VARIABLE_NAMESPACE"]);
 function validateFlowDefinition(flow, capIndex, context) {
   const result = emptyResult();
   const base = `capabilities[${capIndex}].flow`;
@@ -36797,8 +39912,25 @@ function validateFlowDefinition(flow, capIndex, context) {
       }
     }
   }
+  appendNamespaceVariableIssues(flow, base, result);
   return finalize2(result);
 }
+function reprefixCorePath(corePath, base) {
+  if (!corePath) return `${base}.steps`;
+  return corePath.replace(/^flowSteps\[/, `${base}.steps[`);
+}
+function appendNamespaceVariableIssues(flow, base, result) {
+  const parsed = parseCreateFlowValidationInput({ name: flow.name, flowSteps: flow.steps });
+  if (!parsed.success) return;
+  const coreResult = validateFlowStructure(parsed.data);
+  const push = (issue2, severity) => {
+    if (!NAMESPACE_VARIABLE_CODES.has(issue2.code)) return;
+    const bucket = severity === "error" ? result.errors : result.warnings;
+    bucket.push(createIssue(severity, issue2.code, issue2.message, reprefixCorePath(issue2.path, base)));
+  };
+  for (const issue2 of coreResult.errors) push(issue2, "error");
+  for (const issue2 of coreResult.warnings) push(issue2, "warning");
+}
 function finalize2(r) {
   r.valid = r.errors.length === 0;
   return r;
@@ -37426,8 +40558,10 @@ var fullProductObjectTemplateSchema = external_exports.object({
     });
   }
 });
-var FLOW_PREFIX = "flow:";
-var SECRET_PREFIX = "secret:";
+var FLOW_PREFIX = Object.values(RUNTIME_PREFIXES).find((spec) => spec.namespace === "flow").prefix;
+var SECRET_PREFIX = Object.values(RUNTIME_PREFIXES).find(
+  (spec) => spec.namespace === "secret"
+).prefix;
 function collectStringLeafPaths(value, path18 = []) {
   if (typeof value === "string") {
     return [{ path: path18, value }];
@@ -37458,12 +40592,16 @@ function extractTemplateReferences(value) {
     const inner = value.slice(start + 2, end);
     const separatorIndex = inner.indexOf("|");
     const key = (separatorIndex === -1 ? inner : inner.slice(0, separatorIndex)).trim();
-    if (key.length > 0 && !key.startsWith(SECRET_PREFIX) && !key.startsWith(FLOW_PREFIX)) {
-      references.push({
-        key,
-        defaultValue: separatorIndex === -1 ? void 0 : inner.slice(separatorIndex + 1).trim(),
-        raw
-      });
+    if (key.length > 0) {
+      const classification = classifyVariableReference(key);
+      const ownedByRuntimeOrEngine = classification.namespace === "secret" || classification.namespace === "flow" || classification.namespace === "system";
+      if (!ownedByRuntimeOrEngine) {
+        references.push({
+          key,
+          defaultValue: separatorIndex === -1 ? void 0 : inner.slice(separatorIndex + 1).trim(),
+          raw
+        });
+      }
     }
     cursor = end + 2;
   }
@@ -44280,26 +47418,26 @@ async function getCurrentAccountId() {
 
 // src/lib/quick-start-api.ts
 import { RuntypeApiError as RuntypeApiError2 } from "@runtypelabs/sdk";
-function isObjectRecord(value) {
+function isObjectRecord2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isQuickStartValidationResponse(value) {
-  if (!isObjectRecord(value) || typeof value.valid !== "boolean") {
+  if (!isObjectRecord2(value) || typeof value.valid !== "boolean") {
     return false;
   }
   if (value.valid === false) {
     return typeof value.error === "string" && typeof value.code === "string";
   }
-  return typeof value.templateId === "string" && isObjectRecord(value.agentCard);
+  return typeof value.templateId === "string" && isObjectRecord2(value.agentCard);
 }
 function isQuickStartCreateResponse(value) {
-  if (!isObjectRecord(value) || typeof value.success !== "boolean") {
+  if (!isObjectRecord2(value) || typeof value.success !== "boolean") {
     return false;
   }
   if (value.success === false) {
     return typeof value.error === "string" && typeof value.code === "string";
   }
-  return isObjectRecord(value.product) && Array.isArray(value.capabilities) && typeof value.redirectUrl === "string";
+  return isObjectRecord2(value.product) && Array.isArray(value.capabilities) && typeof value.redirectUrl === "string";
 }
 function getApiErrorData(error51) {
   return error51 instanceof RuntypeApiError2 ? error51.data : void 0;
@@ -56323,6 +59461,11 @@ function buildResumeHistoryWarning(state) {
 function canUseMarathonStartupShell(options) {
   return process.stdin.isTTY === true && process.stdout.isTTY === true && !options.json;
 }
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
 function normalizeStartupModelOptionValue(value) {
   const trimmed = value?.trim().toLowerCase().replace(/^model\//, "") ?? "";
   if (!trimmed) return "";
@@ -56903,6 +60046,18 @@ async function taskAction(agent, options) {
   const sandboxWorkflowSelection = playbookWorkflow ? void 0 : resolveSandboxWorkflowSelection(baseMessage, parsedSandbox, resumeState);
   parsedSandbox = sandboxWorkflowSelection?.sandboxProvider ?? parsedSandbox;
   const resolvedWorkflow = playbookWorkflow ?? sandboxWorkflowSelection?.workflow;
+  if (!resolvedWorkflow && !playbookWorkflow && !resumeState && !isDeployCapableSandbox(parsedSandbox) && (isGameIntent(baseMessage) || isDeployIntent(baseMessage))) {
+    console.log(
+      chalk23.yellow(
+        "Hint: this goal looks like a build-and-deploy task, but no deploy-capable sandbox is enabled."
+      )
+    );
+    console.log(
+      chalk23.gray(
+        "  Re-run with --sandbox daytona to build and deploy to a live preview URL (enables the deploy_sandbox tool)."
+      )
+    );
+  }
   const DEFAULT_MILESTONE_NAMES = ["research", "planning", "execution"];
   const EXTERNAL_MILESTONE_NAMES = ["research", "report"];
   const detectedVariant = resumeState?.workflowVariant ?? defaultWorkflow.classifyVariant?.(baseMessage);
@@ -57238,6 +60393,11 @@ Saving state... done. Session saved to ${filePath}`);
     let accumulatedCost = 0;
     let accumulatedTokens = { input: 0, output: 0 };
     let accumulatedToolCalls = 0;
+    let indexedChunks = 0;
+    let indexedBytes = 0;
+    let indexingFailures = 0;
+    let indexingFailureNoticed = false;
+    const indexingRequests = [];
     let lastResult = null;
     let lastSessionMessages = [];
     let undeliveredSteering = [];
@@ -57409,12 +60569,35 @@ Saving state... done. Session saved to ${filePath}`);
               });
               if (chunks.length > 0) {
                 const sessionIdx = currentSessionOffset + state.sessionCount - 1;
-                client.post("/session-context/index", {
+                const payloadBytes = Buffer.byteLength(JSON.stringify(chunks), "utf-8");
+                indexedChunks += chunks.length;
+                indexedBytes += payloadBytes;
+                const NOTICE_BYTES = 512 * 1024;
+                if (payloadBytes >= NOTICE_BYTES) {
+                  reportContextNotice({
+                    kind: "session_indexed",
+                    message: `Session ${sessionIdx} indexed ${chunks.length.toLocaleString()} chunks (${formatBytes(payloadBytes)}) for semantic search.`,
+                    sessionIndex: sessionIdx,
+                    chunkCount: chunks.length,
+                    payloadBytes
+                  });
+                }
+                const indexingRequest = client.post("/session-context/index", {
                   taskName,
                   sessionIndex: sessionIdx,
                   chunks
-                }).catch(() => {
+                }).catch((error51) => {
+                  indexingFailures++;
+                  if (!indexingFailureNoticed) {
+                    indexingFailureNoticed = true;
+                    reportContextNotice({
+                      kind: "indexing_failed",
+                      message: `Session-search indexing failed; recall may be incomplete (${error51 instanceof Error ? error51.message : String(error51)}). Pass --no-session-search to disable indexing.`,
+                      sessionIndex: sessionIdx
+                    });
+                  }
                 });
+                indexingRequests.push(indexingRequest);
               }
             }
           }
@@ -57728,11 +60911,26 @@ Saving state... done. Session saved to ${filePath}`);
     saveState(filePath, finalState, { stripSnapshotEvents: !!eventLogWriter });
     await waitForUiExit?.();
     exitAltScreen();
+    if (indexingRequests.length > 0) {
+      const INDEXING_SETTLE_GRACE_MS = 5e3;
+      await Promise.race([
+        Promise.allSettled(indexingRequests),
+        new Promise((resolve11) => {
+          const timer = setTimeout(resolve11, INDEXING_SETTLE_GRACE_MS);
+          timer.unref?.();
+        })
+      ]);
+    }
     console.log();
     const statusColor = result.status === "complete" ? chalk23.green : result.status === "budget_exceeded" || result.status === "error" ? chalk23.red : chalk23.yellow;
     console.log(`Status:     ${statusColor(result.status)}`);
     console.log(`Sessions:   ${finalState.sessionCount}`);
     console.log(`Total cost: ${chalk23.yellow(`$${finalState.totalCost.toFixed(4)}`)}`);
+    if (indexedChunks > 0 || indexingFailures > 0) {
+      const indexedLine = `${indexedChunks.toLocaleString()} chunks (${formatBytes(indexedBytes)})`;
+      const failureSuffix = indexingFailures > 0 ? chalk23.red(` \u2014 ${indexingFailures} indexing failure${indexingFailures === 1 ? "" : "s"}`) : "";
+      console.log(`Indexed:    ${chalk23.dim(indexedLine)}${failureSuffix}`);
+    }
     console.log(`State:      ${chalk23.gray(filePath)}`);
     if (typeof finalState.lastError === "string" && finalState.lastError.trim()) {
       console.log(`Last error: ${chalk23.red(finalState.lastError)}`);
@@ -57888,7 +61086,20 @@ ${details}`);
   }
   return resolved;
 }
-function detectDeployWorkflow(_message, _sandboxProvider, resumeState) {
+function isDeployCapableSandbox(provider) {
+  return provider === "daytona" || provider === "runtype-sandbox";
+}
+function isGameIntent(message) {
+  const lower = message.toLowerCase();
+  return /\b(game|gameplay|playable|racing|platformer|shooter|puzzle|arcade)\b/.test(lower) || /\b(three\.?js|webgl|phaser|babylon\.?js|pixi\.?js)\b/.test(lower);
+}
+function isDeployIntent(message) {
+  const lower = message.toLowerCase();
+  return /\b(deploy|deployed|deployment|publish|published|host|hosted|hosting|serve|served)\b/.test(
+    lower
+  ) || /\b(web ?app|web ?site|landing page|preview url|live url|public url)\b/.test(lower) || /\b(publicly|share with friends)\b/.test(lower);
+}
+function detectDeployWorkflow(message, sandboxProvider, resumeState) {
   if (resumeState?.workflowVariant === "game") return gameWorkflow;
   if (resumeState?.workflowPhase === "design" || resumeState?.workflowPhase === "build" || resumeState?.workflowPhase === "verify") {
     return gameWorkflow;
@@ -57897,10 +61108,14 @@ function detectDeployWorkflow(_message, _sandboxProvider, resumeState) {
   if (resumeState?.workflowPhase === "scaffold" || resumeState?.workflowPhase === "deploy") {
     return deployWorkflow;
   }
+  if (isDeployCapableSandbox(sandboxProvider)) {
+    if (isGameIntent(message)) return gameWorkflow;
+    if (isDeployIntent(message)) return deployWorkflow;
+  }
   return void 0;
 }
 function resolveSandboxWorkflowSelection(message, sandboxProvider, resumeState) {
-  if (sandboxProvider && sandboxProvider !== "daytona") {
+  if (sandboxProvider && !isDeployCapableSandbox(sandboxProvider)) {
     return {
       workflow: void 0,
       sandboxProvider
@@ -60283,8 +63498,8 @@ import { execFileSync } from "child_process";
 // src/lib/persona-init.ts
 init_credential_store();
 
-// ../../node_modules/.pnpm/@runtypelabs+persona@3.34.0/node_modules/@runtypelabs/persona/dist/codegen.js
-var S = "3.34.0";
+// ../../node_modules/.pnpm/@runtypelabs+persona@3.34.1/node_modules/@runtypelabs/persona/dist/codegen.js
+var S = "3.34.1";
 var c = S;
 function u(e) {
   if (e !== void 0) return typeof e == "string" ? e : Array.isArray(e) ? `[${e.map((r) => r.toString()).join(", ")}]` : e.toString();