@runtypelabs/cli 2.19.0 → 2.19.2

package/dist/index.js

@@ -15164,7 +15164,7 @@ var apiRoutingDocSchema = external_exports.object({
   path: ["api", "activeScript"]
 });
 
-// ../shared/dist/chunk-3V2W6XMX.mjs
+// ../shared/dist/chunk-7Y2SRVP7.mjs
 function getNestedValue(obj, path18) {
   let normalizedPath = path18;
   normalizedPath = normalizedPath.replace(/^\$\.?/, "");
@@ -15200,6 +15200,63 @@ function getNestedValue(obj, path18) {
   return current;
 }
 var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var SYSTEM_VARIABLES = /* @__PURE__ */ new Set([
+  "_flow",
+  "_user",
+  "_execution",
+  "_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",
+  "messageCount"
+]);
+var SECRET_REF_PATTERN = /\{\{secret:([A-Z][A-Z0-9_]*[A-Z0-9])\}\}/g;
+var RUNTIME_PREFIXES = {
+  "secret:": {
+    prefix: "secret:",
+    namespace: "secret",
+    resolvedBy: "the secret pre-pass (substituteSecretReferences) before the template engine runs \u2014 never the template engine itself",
+    mayReachModelUnresolved: false
+  },
+  "flow:": {
+    prefix: "flow:",
+    namespace: "flow",
+    resolvedBy: "the template engine, which treats it as an alias for the bare flow variable of the same name",
+    mayReachModelUnresolved: false
+  }
+};
+var PREFIX_PATTERN = /^([A-Za-z][A-Za-z0-9_-]*):(.*)$/s;
+function classifyVariableReference(token) {
+  const trimmed = token.trim();
+  const prefixMatch = PREFIX_PATTERN.exec(trimmed);
+  if (prefixMatch) {
+    const prefix = `${prefixMatch[1]}:`;
+    const rest = prefixMatch[2] ?? "";
+    const spec = RUNTIME_PREFIXES[prefix];
+    if (spec) {
+      return { namespace: spec.namespace, baseName: rest.trim() };
+    }
+    return { namespace: "unknown", raw: trimmed };
+  }
+  if (isSystemVariable(trimmed)) {
+    return { namespace: "system", baseName: trimmed };
+  }
+  return { namespace: "plain", baseName: trimmed };
+}
+function isSystemVariable(varName) {
+  const rootSegment = varName.split(".")[0] || "";
+  return SYSTEM_VARIABLES.has(rootSegment);
+}
 var TEMPLATE_EXPRESSION_PATTERN = /\{\{([^{}]+)\}\}/g;
 function parseTemplateExpression(expr) {
   const tokens = tokenizeFallbackExpression(expr);
@@ -15286,7 +15343,7 @@ function parseOperand(raw) {
 }
 function evaluateOperand(operand, context) {
   if (operand.kind === "literal") return operand.value;
-  return getNestedValue(context, operand.path);
+  return getNestedValue(context, classifiedLookupKey(operand.path));
 }
 function countTrailingBackslashes(s, i) {
   let n = 0;
@@ -15306,11 +15363,24 @@ 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 = [];
     const usedDefaults = [];
     const missingVariables = [];
+    const unknownNamespaceVariables = [];
     const result = template.replace(_SimpleTemplateEngine2.EXPRESSION_PATTERN, (match, expr) => {
       let parsed;
       try {
@@ -15323,12 +15393,14 @@ var _SimpleTemplateEngine = class _SimpleTemplateEngine2 {
           usedVariables,
           usedDefaults,
           missingVariables,
+          unknownNamespaceVariables,
           match
         });
       }
       return resolveFallback(parsed, context, {
         usedVariables,
         missingVariables,
+        unknownNamespaceVariables,
         match
       });
     });
@@ -15336,7 +15408,8 @@ var _SimpleTemplateEngine = class _SimpleTemplateEngine2 {
       result,
       usedVariables,
       usedDefaults,
-      missingVariables
+      missingVariables,
+      unknownNamespaceVariables
     };
   }
   /**
@@ -15411,28 +15484,49 @@ var _SimpleTemplateEngine = class _SimpleTemplateEngine2 {
 };
 _SimpleTemplateEngine.EXPRESSION_PATTERN = TEMPLATE_EXPRESSION_PATTERN;
 var SimpleTemplateEngine = _SimpleTemplateEngine;
+function classifiedLookupKey(rawKey, onUnknown) {
+  const classification = classifyVariableReference(rawKey);
+  if (classification.namespace === "flow") {
+    return classification.baseName;
+  }
+  if (classification.namespace === "unknown") {
+    onUnknown?.(classification.raw);
+    return rawKey;
+  }
+  return rawKey;
+}
 function resolveLegacy(parsed, context, tracking) {
-  const value = getNestedValue(context, parsed.variable);
+  const lookupKey = classifiedLookupKey(
+    parsed.variable,
+    (raw) => tracking.unknownNamespaceVariables.push(raw)
+  );
+  const value = getNestedValue(context, lookupKey);
   if (value !== void 0 && value !== null) {
-    tracking.usedVariables.push(parsed.variable);
+    tracking.usedVariables.push(lookupKey);
     return stringifyValue(value);
   }
   if (parsed.defaultValue !== void 0) {
     tracking.usedDefaults.push({
-      variable: parsed.variable,
+      variable: lookupKey,
       defaultValue: parsed.defaultValue
     });
     return parsed.defaultValue;
   }
-  tracking.missingVariables.push(parsed.variable);
+  tracking.missingVariables.push(lookupKey);
   return tracking.match;
 }
 function resolveFallback(parsed, context, tracking) {
   let chosen = null;
   for (const operand of parsed.operands) {
     const value = evaluateOperand(operand, context);
-    if (operand.kind === "path" && value !== void 0) {
-      tracking.usedVariables.push(operand.path);
+    if (operand.kind === "path") {
+      const key = classifiedLookupKey(
+        operand.path,
+        (raw) => tracking.unknownNamespaceVariables.push(raw)
+      );
+      if (value !== void 0) {
+        tracking.usedVariables.push(key);
+      }
     }
     if (chosen === null && passesOperator(value, parsed.operator)) {
       chosen = { value, isPath: operand.kind === "path" };
@@ -15444,13 +15538,18 @@ function resolveFallback(parsed, context, tracking) {
     return stringifyValue(last.value);
   }
   for (const operand of parsed.operands) {
-    if (operand.kind === "path") tracking.missingVariables.push(operand.path);
+    if (operand.kind === "path") {
+      tracking.missingVariables.push(classifiedLookupKey(operand.path));
+    }
   }
   return tracking.match;
 }
 var templateEngine = new SimpleTemplateEngine();
 
 // ../shared/dist/index.mjs
+function neutralizeCsvFormula(value) {
+  return /^[=+\-@\t\r\n]/.test(value) ? `'${value}` : value;
+}
 var mediaAnnotationsSchema = external_exports.object({
   audience: external_exports.array(external_exports.enum(["user", "assistant"])).optional()
 });
@@ -15907,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,
@@ -16362,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({
@@ -17168,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
@@ -17227,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() {
@@ -30449,7 +33642,7 @@ var CORE_BUILTIN_TOOLS_REGISTRY = [
   {
     id: "publish_page",
     name: "Publish Page",
-    description: "Publish an HTML page on Runtype's CDN and get back a shareable URL that renders the page inline in the browser. Two source modes: (1) pass `url` to download an HTML file from an HTTP(S) URL, or (2) pass base64-encoded `content` (defaults to `contentType: text/html`) to upload inline HTML directly \u2014 useful when running inside a sandboxed code-execution environment with restricted outbound network. Exactly one of `url` or `content` must be provided. Served inline from a `/preview/` path under a locked-down CSP that blocks scripts, network requests, and form submissions. Page URLs are public and expire after 7 days. Accepts only HTML content. 25 MB max. To host a non-HTML file, or HTML as a permanent downloadable file, use `store_asset` instead.",
+    description: "Publish an HTML page on Runtype's CDN and get back a shareable URL that renders the page inline in the browser. Two source modes: (1) pass `url` to download an HTML file from an HTTP(S) URL, or (2) pass base64-encoded `content` (defaults to `contentType: text/html`) to upload inline HTML directly \u2014 useful when running inside a sandboxed code-execution environment with restricted outbound network. Exactly one of `url` or `content` must be provided. Served inline from a `/preview/` path under a locked-down CSP that blocks scripts, network requests, and form submissions. Page URLs are public and expire based on the account's plan (7 days on the default plan; longer or permanent on higher tiers \u2014 check `expiresAt` in the result). Pass `expiresInSeconds` to choose a shorter lifetime; the plan TTL is a hard ceiling. A page can be re-upped to the current plan TTL at the same URL via `POST /v1/assets/:assetId/extend`. Accepts only HTML content. 25 MB max. To host a non-HTML file, or HTML as a permanent downloadable file, use `store_asset` instead.",
     category: BuiltInToolCategory.FILE_OPERATIONS,
     toolGroup: BuiltInToolGroup.FILE_OUTPUTS,
     providers: [BuiltInToolProvider.MULTI],
@@ -30471,6 +33664,10 @@ var CORE_BUILTIN_TOOLS_REGISTRY = [
         filename: {
           type: "string",
           description: "Optional filename for the stored page"
+        },
+        expiresInSeconds: {
+          type: "number",
+          description: "Optional page lifetime in seconds (positive integer). Capped at the account plan's preview TTL \u2014 a shorter lifetime is honored, a longer one is clamped to the plan ceiling. Omit to use the plan default."
         }
       },
       required: []
@@ -33524,7 +36721,11 @@ var userProfileFeaturesSchema = external_exports.object({
   // Gates the chrome_extension surface type in the dashboard (surface picker
   // and downstream config/ship UI). Driven by the `CHROME_SURFACE` boolean
   // flag.
-  enableChromeSurface: external_exports.boolean()
+  enableChromeSurface: external_exports.boolean(),
+  // Gates the Runtype Apps nav entry + routes in the dashboard. Driven by the
+  // `enable-runtype-apps` boolean flag (fail-closed in production until the
+  // prod ops set lands). The whole /v1/apps surface 404s when this is off.
+  enableRuntypeApps: external_exports.boolean()
 });
 var MODEL_FAMILY_PROVIDER_IDS = {
   "claude-fable-5": {
@@ -36160,7 +39361,6 @@ var agentRuntimeConfigSchema = external_exports.object({
   // mirroring how `temporalConfigSchema` is shared.
   memory: memoryConfigSchema.optional()
 });
-var SECRET_REF_PATTERN = /\{\{secret:([A-Z][A-Z0-9_]*[A-Z0-9])\}\}/g;
 function extractSecretReferences(template) {
   const keys = /* @__PURE__ */ new Set();
   let match;
@@ -36651,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`;
@@ -36711,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;
@@ -37340,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 }];
@@ -37372,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;
   }
@@ -41126,6 +44350,131 @@ recordsCommand.command("get <id>").description("Get record details").option("--j
   const { waitUntilExit } = render3(React3.createElement(App));
   await waitUntilExit();
 });
+recordsCommand.command("results <id>").description("Get step-level execution results for a record").option("--flow-id <flowId>", "Filter by flow ID").option("--batch-id <batchId>", "Filter by batch ID").option("--status <status>", "Filter by status").option("--limit <n>", "Limit number of results").option("--offset <n>", "Offset for pagination").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(
+  async (id, options) => {
+    const apiKey = await ensureAuth();
+    if (!apiKey) return;
+    const client = createCliClient(apiKey);
+    const params = {
+      ...options.flowId ? { flowId: options.flowId } : {},
+      ...options.batchId ? { batchId: options.batchId } : {},
+      ...options.status ? { status: options.status } : {},
+      ...options.limit ? { limit: parseInt(options.limit, 10) } : {},
+      ...options.offset ? { offset: parseInt(options.offset, 10) } : {}
+    };
+    if (!isTTY(options) || options.json) {
+      try {
+        const data = await client.records.getStepResults(id, params);
+        if (options.json) {
+          printJson(data);
+          return;
+        }
+        const results = data.data ?? [];
+        if (results.length === 0) {
+          console.log(chalk6.yellow("No step results found"));
+          return;
+        }
+        for (const r of results) {
+          console.log(
+            `  ${chalk6.green(r.id)}  ${r.stepName} (${r.stepType})  ${r.status}` + (r.modelUsed ? `  ${r.modelUsed}` : "")
+          );
+        }
+      } catch (error51) {
+        const message = error51 instanceof Error ? error51.message : "Unknown error";
+        console.error(chalk6.red(`Failed to fetch step results: ${message}`));
+        process.exit(1);
+      }
+      return;
+    }
+    const App = () => {
+      const [items, setItems] = useState4(null);
+      const [error51, setError] = useState4(null);
+      useEffect5(() => {
+        client.records.getStepResults(id, params).then((res) => setItems(res.data ?? [])).catch((err) => setError(err instanceof Error ? err : new Error(String(err))));
+      }, []);
+      return React3.createElement(DataList, {
+        title: "Step results",
+        items,
+        error: error51,
+        loading: items === null && error51 === null,
+        renderCard: (item) => {
+          const r = item;
+          return React3.createElement(EntityCard, {
+            fields: [
+              { label: "ID", value: r.id, color: "green" },
+              { label: "Step", value: `${r.stepName} (${r.stepType})` },
+              { label: "Status", value: r.status },
+              { label: "Model", value: r.modelUsed ?? null },
+              {
+                label: "Duration",
+                value: r.durationMs !== null ? `${r.durationMs}ms` : null
+              }
+            ]
+          });
+        }
+      });
+    };
+    const { waitUntilExit } = render3(React3.createElement(App));
+    await waitUntilExit();
+  }
+);
+recordsCommand.command("costs <id>").description("Get aggregated cost breakdown for a record").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (id, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const client = createCliClient(apiKey);
+  if (!isTTY(options) || options.json) {
+    try {
+      const data = await client.records.getCosts(id);
+      if (options.json) {
+        printJson(data);
+        return;
+      }
+      console.log(`  Total cost: $${data.totalCost}`);
+      console.log(`  Total tokens: ${data.totalTokens}`);
+      console.log(`  Executions: ${data.executionCount}`);
+      if (data.modelBreakdown.length > 0) {
+        console.log("  By model:");
+        for (const m2 of data.modelBreakdown) {
+          console.log(`    ${m2.model}: $${m2.cost}  ${m2.tokens} tokens  ${m2.count} calls`);
+        }
+      }
+    } catch (error51) {
+      const message = error51 instanceof Error ? error51.message : "Unknown error";
+      console.error(chalk6.red(`Failed to fetch record costs: ${message}`));
+      process.exit(1);
+    }
+    return;
+  }
+  const App = () => {
+    const [items, setItems] = useState4(null);
+    const [error51, setError] = useState4(null);
+    useEffect5(() => {
+      client.records.getCosts(id).then((res) => setItems([res])).catch((err) => setError(err instanceof Error ? err : new Error(String(err))));
+    }, []);
+    return React3.createElement(DataList, {
+      title: "Record costs",
+      items,
+      error: error51,
+      loading: items === null && error51 === null,
+      renderCard: (item) => {
+        const c2 = item;
+        return React3.createElement(EntityCard, {
+          fields: [
+            { label: "Total cost", value: `$${c2.totalCost}`, color: "green" },
+            { label: "Total tokens", value: String(c2.totalTokens) },
+            { label: "Executions", value: String(c2.executionCount) },
+            {
+              label: "Models",
+              value: c2.modelBreakdown.map((m2) => `${m2.model} ($${m2.cost})`).join(", ") || null
+            }
+          ]
+        });
+      }
+    });
+  };
+  const { waitUntilExit } = render3(React3.createElement(App));
+  await waitUntilExit();
+});
 recordsCommand.command("create").description("Create a new record").requiredOption("-n, --name <name>", "Record name").requiredOption("-t, --type <type>", "Record type").option("-m, --metadata <json>", "Metadata as JSON string").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(
   async (options) => {
     const apiKey = await ensureAuth();
@@ -41533,10 +44882,11 @@ recordsCommand.command("export").description("Export records to a file").option(
   }
 });
 function csvEscape(value) {
-  if (value.includes(",") || value.includes('"') || value.includes("\n")) {
-    return `"${value.replace(/"/g, '""')}"`;
+  const text = neutralizeCsvFormula(value);
+  if (text.includes(",") || text.includes('"') || text.includes("\n")) {
+    return `"${text.replace(/"/g, '""')}"`;
   }
-  return value;
+  return text;
 }
 
 // src/commands/prompts.ts
@@ -44068,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;
@@ -48903,29 +52253,40 @@ function primeTreeLogSyncFromState(stateFilePath2, log, state) {
     lastCheckpointJson: JSON.stringify(toCheckpoint(state))
   });
 }
+function ensureTreeLogSync(stateFilePath2, seed) {
+  const logPath = treeLogPathForStateFile(stateFilePath2);
+  let sync = syncStates.get(stateFilePath2);
+  if (!sync || sync.log.filePath !== logPath) {
+    const existing = loadTreeLog(logPath);
+    if (existing) {
+      const materialized = materializeAtHead(existing);
+      sync = {
+        log: existing,
+        lastMessages: materialized?.messages ?? [],
+        lastCheckpointJson: JSON.stringify(materialized?.state ?? null)
+      };
+    } else {
+      const log = createTreeLog(logPath, {
+        taskName: seed.taskName,
+        agentId: seed.agentId,
+        ...seed.originalMessage ? { originalMessage: seed.originalMessage } : {}
+      });
+      sync = { log, lastMessages: [], lastCheckpointJson: "null" };
+    }
+    syncStates.set(stateFilePath2, sync);
+  }
+  return sync;
+}
+function getOrLoadTreeLogSync(stateFilePath2, seed) {
+  return ensureTreeLogSync(stateFilePath2, seed).log;
+}
 function syncTreeLogWithState(stateFilePath2, state) {
   try {
-    const logPath = treeLogPathForStateFile(stateFilePath2);
-    let sync = syncStates.get(stateFilePath2);
-    if (!sync || sync.log.filePath !== logPath) {
-      const existing = loadTreeLog(logPath);
-      if (existing) {
-        const materialized = materializeAtHead(existing);
-        sync = {
-          log: existing,
-          lastMessages: materialized?.messages ?? [],
-          lastCheckpointJson: JSON.stringify(materialized?.state ?? null)
-        };
-      } else {
-        const log = createTreeLog(logPath, {
-          taskName: state.taskName,
-          agentId: state.agentId,
-          ...state.originalMessage ? { originalMessage: state.originalMessage } : {}
-        });
-        sync = { log, lastMessages: [], lastCheckpointJson: "null" };
-      }
-      syncStates.set(stateFilePath2, sync);
-    }
+    const sync = ensureTreeLogSync(stateFilePath2, {
+      taskName: state.taskName,
+      agentId: state.agentId,
+      ...state.originalMessage ? { originalMessage: state.originalMessage } : {}
+    });
     const nextMessages = state.messages ?? sync.lastMessages;
     const messagesDelta = computeMessagesDelta(sync.lastMessages, nextMessages);
     const checkpoint = toCheckpoint(state);
@@ -55472,9 +58833,8 @@ function stateFilePathForTask(taskName, stateDir) {
 }
 function recordOffloadedArtifact(details) {
   const stateFilePath2 = details.options.ledger?.stateFilePath || stateFilePathForTask(details.taskName, details.stateDir);
-  const logPath = treeLogPathForStateFile(stateFilePath2);
   try {
-    const log = loadTreeLog(logPath) || createTreeLog(logPath, {
+    const log = getOrLoadTreeLogSync(stateFilePath2, {
       taskName: details.taskName,
       agentId: details.options.ledger?.agentId || "unknown",
       ...details.options.ledger?.originalMessage ? { originalMessage: details.options.ledger.originalMessage } : {}
@@ -56101,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 "";
@@ -56681,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);
@@ -56803,6 +60180,30 @@ ${rulesContext}`;
     return tools;
   };
   localTools = applyOffloadWrapping(localTools);
+  const ledgerOffloadRecorder = offloadOptions ? (details) => {
+    const result = offloadToolOutput(
+      taskName,
+      details.toolName,
+      details.content,
+      {
+        ...offloadOptions,
+        threshold: 0,
+        ledger: { stateFilePath: filePath, agentId, originalMessage: baseMessage },
+        onEvent: (event) => {
+          if (event.kind !== "offloaded") return;
+          reportContextNotice({
+            kind: "tool_output_offloaded",
+            message: `${event.toolName} returned ${Math.ceil(event.outputLength / 4).toLocaleString()} estimated tokens and was offloaded to the context ledger to protect the context window.`,
+            toolName: event.toolName,
+            outputLength: event.outputLength,
+            filePath: event.filePath
+          });
+        }
+      },
+      options.stateDir
+    );
+    return result.offloaded ? { reference: result.content } : void 0;
+  } : void 0;
   let toolsEnabled = true;
   const checkpointHasConfigChanges = (result) => Boolean(result.model) || result.tools === true || result.sandbox !== void 0;
   const rebuildCheckpointTools = () => applyOffloadWrapping(
@@ -56992,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 = [];
@@ -57053,6 +60459,7 @@ Saving state... done. Session saved to ${filePath}`);
         stream: true,
         streamCallbacks: currentStreamCallbacks,
         localTools,
+        ...ledgerOffloadRecorder ? { offloadRecorder: ledgerOffloadRecorder } : {},
         trackProgress: options.track ? taskName : void 0,
         // Mid-run steering queue (Enter while streaming): the UI owns the
         // queue; the SDK drains it at session boundaries and ends in-flight
@@ -57162,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);
               }
             }
           }
@@ -57481,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)}`);
@@ -57641,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;
@@ -57650,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
@@ -60036,9 +63498,9 @@ import { execFileSync } from "child_process";
 // src/lib/persona-init.ts
 init_credential_store();
 
-// ../../node_modules/.pnpm/@runtypelabs+persona@3.31.0/node_modules/@runtypelabs/persona/dist/codegen.js
-var S = { name: "@runtypelabs/persona", version: "3.31.0", description: "Themeable, pluggable streaming agent widget for websites, in plain JS with support for voice input and reasoning / tool output.", type: "module", main: "dist/index.cjs", module: "dist/index.js", types: "dist/index.d.ts", exports: { ".": { types: "./dist/index.d.ts", import: "./dist/index.js", require: "./dist/index.cjs" }, "./theme-reference": { types: "./dist/theme-reference.d.ts", import: "./dist/theme-reference.js", require: "./dist/theme-reference.cjs" }, "./codegen": { types: "./dist/codegen.d.ts", import: "./dist/codegen.js", require: "./dist/codegen.cjs" }, "./theme-editor": { types: "./dist/theme-editor.d.ts", import: "./dist/theme-editor.js", require: "./dist/theme-editor.cjs" }, "./testing": { types: "./dist/testing.d.ts", import: "./dist/testing.js", require: "./dist/testing.cjs" }, "./smart-dom-reader": { types: "./dist/smart-dom-reader.d.ts", import: "./dist/smart-dom-reader.js", require: "./dist/smart-dom-reader.cjs" }, "./plugin-kit": { types: "./dist/plugin-kit.d.ts", import: "./dist/plugin-kit.js", require: "./dist/plugin-kit.cjs" }, "./animations/glyph-cycle": { types: "./dist/animations/glyph-cycle.d.ts", import: "./dist/animations/glyph-cycle.js", require: "./dist/animations/glyph-cycle.cjs" }, "./animations/wipe": { types: "./dist/animations/wipe.d.ts", import: "./dist/animations/wipe.js", require: "./dist/animations/wipe.cjs" }, "./widget.css": "./dist/widget.css" }, files: ["dist", "src"], scripts: { build: "rimraf dist && pnpm run build:styles && pnpm run build:client && pnpm run build:installer && pnpm run build:launcher && pnpm run build:theme-ref && pnpm run build:codegen && pnpm run build:theme-editor && pnpm run build:testing && pnpm run build:smart-dom-reader && pnpm run build:plugin-kit && pnpm run build:animations", "build:plugin-kit": "tsup src/plugin-kit.ts --format esm,cjs --minify --dts --out-dir dist --no-splitting", "build:theme-editor": "tsup src/theme-editor.ts --format esm,cjs --minify --dts --out-dir dist --no-splitting", "build:testing": "tsup src/testing.ts --format esm,cjs --minify --dts --out-dir dist --no-splitting", "build:smart-dom-reader": "tsup src/smart-dom-reader.ts --format esm,cjs --minify --dts --out-dir dist --no-splitting", "build:animations": "tsup src/animations/glyph-cycle.ts src/animations/wipe.ts --format esm,cjs --minify --dts --out-dir dist/animations --no-splitting", "build:theme-ref": "tsup src/theme-reference.ts --format esm,cjs --minify --dts", "build:codegen": "tsup src/codegen.ts --format esm,cjs --minify --dts", "build:styles": `node -e "const fs=require('fs');fs.mkdirSync('dist',{recursive:true});fs.copyFileSync('src/styles/widget.css','dist/widget.css');"`, "build:client": `tsup src/index.ts --format esm,cjs --minify --sourcemap --splitting false --dts --loader ".css=text" && tsup src/index-global.ts --format iife --global-name AgentWidget --minify --sourcemap --splitting false --out-dir dist --loader ".css=text" && node -e "const fs=require('fs');for(const ext of ['.global.js','.global.js.map']){const from='dist/index-global'+ext;if(fs.existsSync(from))fs.renameSync(from,'dist/index'+ext);}"`, "build:installer": "tsup src/install.ts --format iife --global-name SiteAgentInstaller --out-dir dist --minify --sourcemap --no-splitting", "build:launcher": `tsup src/launcher-global.ts --format iife --global-name AgentWidgetLauncher --minify --sourcemap --splitting false --out-dir dist && node -e "const fs=require('fs');for(const ext of ['.global.js','.global.js.map']){const from='dist/launcher-global'+ext;if(fs.existsSync(from))fs.renameSync(from,'dist/launcher'+ext);}"`, lint: "eslint . --ext .ts", typecheck: "pnpm run check:runtype-types && tsc --noEmit", test: "vitest", "test:ui": "vitest --ui", "test:run": "vitest run", size: "size-limit", "fetch:runtype-openapi": "node scripts/fetch-runtype-openapi.mjs", "generate:runtype-types": "pnpm run fetch:runtype-openapi && node scripts/generate-runtype-openapi-types.mjs", "check:runtype-types": "pnpm run fetch:runtype-openapi && node scripts/generate-runtype-openapi-types.mjs --check" }, dependencies: { "@mcp-b/webmcp-polyfill": "^3.0.0", dompurify: "^3.3.3", idiomorph: "^0.7.4", lucide: "^0.552.0", marked: "^12.0.2", "partial-json": "^0.1.7", zod: "^3.22.4" }, devDependencies: { "@size-limit/file": "^12.1.0", "@types/node": "^20.12.7", "@typescript-eslint/eslint-plugin": "^7.0.0", "@typescript-eslint/parser": "^7.0.0", "@vitest/ui": "^4.0.9", eslint: "^8.57.0", "eslint-config-prettier": "^9.1.0", "fake-indexeddb": "^6.2.5", rimraf: "^5.0.5", "size-limit": "^12.1.0", tsup: "^8.0.1", typescript: "^5.4.5", vitest: "^4.0.9" }, engines: { node: ">=20.0.0" }, author: "Runtype", license: "MIT", keywords: ["ai", "chat", "widget", "streaming", "typescript", "persona", "agent"], repository: { type: "git", url: "git+https://github.com/runtypelabs/persona.git", directory: "packages/widget" }, bugs: { url: "https://github.com/runtypelabs/persona/issues" }, homepage: "https://github.com/runtypelabs/persona/tree/main/packages/widget#readme", publishConfig: { access: "public" } };
-var c = S.version;
+// ../../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();
 }
@@ -60200,7 +63662,7 @@ function I(e, r = "esm", n) {
   let s = { ...e };
   delete s.postprocessMessage, delete s.initialMessages;
   let o = n ? { ...n, hooks: T(n.hooks) } : void 0;
-  return r === "esm" ? W(s, o) : r === "script-installer" ? k(s, o) : r === "script-advanced" ? F(s, o) : r === "react-component" ? H(s, o) : r === "react-advanced" ? N(s, o) : D(s, o);
+  return r === "esm" ? W(s, o) : r === "script-installer" ? D(s, o) : r === "script-advanced" ? F(s, o) : r === "react-component" ? H(s, o) : r === "react-advanced" ? N(s, o) : k(s, o);
 }
 function W(e, r) {
   let n = r == null ? void 0 : r.hooks, s = h(e), o = s !== "plain", t = ["import '@runtypelabs/persona/widget.css';", "import { initAgentWidget, markdownPostprocessor } from '@runtypelabs/persona';", "", "initAgentWidget({", `  target: '${g(r)}',`, "  config: {"];
@@ -60296,11 +63758,11 @@ function P(e) {
   }
   return s;
 }
-function k(e, r) {
+function D(e, r) {
   let n = P(e), o = !!(r != null && r.windowKey || r != null && r.target) ? { config: n, ...r != null && r.windowKey ? { windowKey: r.windowKey } : {}, ...r != null && r.target ? { target: r.target } : {} } : n, t = JSON.stringify(o, null, 0).replace(/'/g, "&#39;");
   return `<script src="https://cdn.jsdelivr.net/npm/@runtypelabs/persona@${c}/dist/install.global.js" data-config='${t}'></script>`;
 }
-function D(e, r) {
+function k(e, r) {
   let n = r == null ? void 0 : r.hooks, s = h(e), o = s !== "plain", t = ["<!-- Load CSS -->", `<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@runtypelabs/persona@${c}/dist/widget.css" />`, "", "<!-- Load JavaScript -->", `<script src="https://cdn.jsdelivr.net/npm/@runtypelabs/persona@${c}/dist/index.global.js"></script>`, "", "<!-- Initialize widget -->", "<script>", "  var handle = window.AgentWidget.initAgentWidget({", `    target: '${g(r)}',`, ...r != null && r.windowKey ? [`    windowKey: '${r.windowKey}',`] : [], "    config: {"];
   return e.apiUrl && t.push(`      apiUrl: "${e.apiUrl}",`), e.clientToken && t.push(`      clientToken: "${e.clientToken}",`), e.flowId && t.push(`      flowId: "${e.flowId}",`), o && t.push(`      parserType: "${s}",`), e.theme && typeof e.theme == "object" && Object.keys(e.theme).length > 0 && l(t, "theme", e.theme, "      "), e.launcher && l(t, "launcher", e.launcher, "      "), e.copy && (t.push("      copy: {"), Object.entries(e.copy).forEach(([i, a]) => {
     t.push(`        ${i}: "${a}",`);