@remoraflow/core 0.1.0

package/dist/lib.js

@@ -0,0 +1,3566 @@
+// src/compiler/index.ts
+import { asSchema } from "ai";
+
+// src/compiler/passes/apply-best-practices.ts
+var rules = [addMissingStartStep, addMissingEndSteps];
+function applyBestPractices(workflow, graph) {
+  let result = structuredClone(workflow);
+  const allDiagnostics = [];
+  for (const rule of rules) {
+    const ruleResult = rule(result, graph);
+    result = ruleResult.workflow;
+    allDiagnostics.push(...ruleResult.diagnostics);
+  }
+  return { workflow: result, diagnostics: allDiagnostics };
+}
+function addMissingStartStep(workflow, _graph) {
+  const diagnostics = [];
+  const hasStartStep = workflow.steps.some((s) => s.type === "start");
+  if (hasStartStep) {
+    return { workflow, diagnostics };
+  }
+  const startStepId = "__start";
+  const oldInitialStepId = workflow.initialStepId;
+  const startStep = {
+    id: startStepId,
+    name: "Start",
+    description: "Auto-generated start step",
+    type: "start",
+    nextStepId: oldInitialStepId
+  };
+  workflow.steps.unshift(startStep);
+  workflow.initialStepId = startStepId;
+  diagnostics.push({
+    severity: "warning",
+    location: { stepId: null, field: "initialStepId" },
+    message: "Workflow has no start step; one was automatically added with an empty input schema",
+    code: "MISSING_START_STEP"
+  });
+  return { workflow, diagnostics };
+}
+function addMissingEndSteps(workflow, _graph) {
+  const newEndSteps = [];
+  for (const step of workflow.steps) {
+    if (step.type === "end")
+      continue;
+    if (step.nextStepId)
+      continue;
+    const endStepId = `${step.id}_end`;
+    step.nextStepId = endStepId;
+    newEndSteps.push({
+      id: endStepId,
+      name: "End",
+      description: `End of chain after ${step.id}`,
+      type: "end"
+    });
+  }
+  workflow.steps.push(...newEndSteps);
+  return { workflow, diagnostics: [] };
+}
+
+// src/compiler/utils/graph.ts
+function buildStepIndex(steps) {
+  const index = new Map;
+  const duplicates = [];
+  for (const step of steps) {
+    if (index.has(step.id)) {
+      duplicates.push(step.id);
+    } else {
+      index.set(step.id, step);
+    }
+  }
+  return { index, duplicates };
+}
+function computeSuccessors(stepIndex) {
+  const successors = new Map;
+  for (const [id, step] of stepIndex) {
+    const succs = new Set;
+    if (step.nextStepId) {
+      succs.add(step.nextStepId);
+    }
+    if (step.type === "switch-case") {
+      for (const c of step.params.cases) {
+        succs.add(c.branchBodyStepId);
+      }
+    }
+    if (step.type === "for-each") {
+      succs.add(step.params.loopBodyStepId);
+    }
+    if (step.type === "wait-for-condition") {
+      succs.add(step.params.conditionStepId);
+    }
+    successors.set(id, succs);
+  }
+  return successors;
+}
+function computeReachability(initialStepId, successors) {
+  const reachable = new Set;
+  const queue = [initialStepId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === undefined)
+      break;
+    if (reachable.has(current))
+      continue;
+    reachable.add(current);
+    const succs = successors.get(current);
+    if (succs) {
+      for (const s of succs) {
+        if (!reachable.has(s)) {
+          queue.push(s);
+        }
+      }
+    }
+  }
+  return reachable;
+}
+function detectCycles(stepIndex, successors) {
+  const WHITE = 0;
+  const GRAY = 1;
+  const BLACK = 2;
+  const color = new Map;
+  for (const id of stepIndex.keys()) {
+    color.set(id, WHITE);
+  }
+  const cycles = [];
+  const path = [];
+  function dfs(node) {
+    if (!stepIndex.has(node))
+      return;
+    color.set(node, GRAY);
+    path.push(node);
+    const succs = successors.get(node);
+    if (succs) {
+      for (const next of succs) {
+        if (!stepIndex.has(next))
+          continue;
+        const c = color.get(next);
+        if (c === undefined)
+          continue;
+        if (c === GRAY) {
+          const cycleStart = path.indexOf(next);
+          cycles.push(path.slice(cycleStart));
+        } else if (c === WHITE) {
+          dfs(next);
+        }
+      }
+    }
+    path.pop();
+    color.set(node, BLACK);
+  }
+  for (const id of stepIndex.keys()) {
+    if (color.get(id) === WHITE) {
+      dfs(id);
+    }
+  }
+  return cycles;
+}
+function computePredecessors(topologicalOrder, successors) {
+  const predecessors = new Map;
+  for (const id of topologicalOrder) {
+    predecessors.set(id, new Set);
+  }
+  for (const id of topologicalOrder) {
+    const succs = successors.get(id);
+    if (!succs)
+      continue;
+    for (const succ of succs) {
+      const predSet = predecessors.get(succ);
+      if (!predSet)
+        continue;
+      predSet.add(id);
+      const idPreds = predecessors.get(id);
+      if (idPreds) {
+        for (const p of idPreds) {
+          predSet.add(p);
+        }
+      }
+    }
+  }
+  return predecessors;
+}
+function topologicalSort(stepIds, successors) {
+  const inDegree = new Map;
+  const stepIdSet = new Set(stepIds);
+  for (const id of stepIds) {
+    inDegree.set(id, 0);
+  }
+  for (const id of stepIds) {
+    const succs = successors.get(id);
+    if (!succs)
+      continue;
+    for (const s of succs) {
+      if (stepIdSet.has(s)) {
+        inDegree.set(s, (inDegree.get(s) ?? 0) + 1);
+      }
+    }
+  }
+  const queue = [];
+  for (const [id, deg] of inDegree) {
+    if (deg === 0)
+      queue.push(id);
+  }
+  const order = [];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    if (node === undefined)
+      break;
+    order.push(node);
+    const succs = successors.get(node);
+    if (!succs)
+      continue;
+    for (const s of succs) {
+      if (!stepIdSet.has(s))
+        continue;
+      const currentDeg = inDegree.get(s);
+      if (currentDeg === undefined)
+        continue;
+      const newDeg = currentDeg - 1;
+      inDegree.set(s, newDeg);
+      if (newDeg === 0) {
+        queue.push(s);
+      }
+    }
+  }
+  return order.length === stepIds.length ? order : null;
+}
+function computeLoopScopesAndOwnership(initialStepId, stepIndex) {
+  const loopVariablesInScope = new Map;
+  const bodyOwnership = new Map;
+  function walkChain(startId, loopVars, ownerStepId) {
+    let currentId = startId;
+    const chainSteps = [];
+    while (currentId) {
+      if (loopVariablesInScope.has(currentId))
+        break;
+      const step = stepIndex.get(currentId);
+      if (!step)
+        break;
+      loopVariablesInScope.set(currentId, new Set(loopVars));
+      if (ownerStepId !== null) {
+        bodyOwnership.set(currentId, ownerStepId);
+      }
+      chainSteps.push(step);
+      currentId = step.nextStepId;
+    }
+    for (const step of chainSteps) {
+      if (step.type === "for-each") {
+        const innerVars = new Set(loopVars);
+        innerVars.add(step.params.itemName);
+        walkChain(step.params.loopBodyStepId, innerVars, step.id);
+      }
+      if (step.type === "switch-case") {
+        for (const c of step.params.cases) {
+          walkChain(c.branchBodyStepId, loopVars, step.id);
+        }
+      }
+      if (step.type === "wait-for-condition") {
+        walkChain(step.params.conditionStepId, loopVars, step.id);
+      }
+    }
+  }
+  walkChain(initialStepId, new Set, null);
+  return { loopVariablesInScope, bodyOwnership };
+}
+
+// src/compiler/passes/build-graph.ts
+function buildGraph(workflow) {
+  const diagnostics = [];
+  const VALID_STEP_ID = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+  for (const step of workflow.steps) {
+    if (!VALID_STEP_ID.test(step.id)) {
+      diagnostics.push({
+        severity: "error",
+        location: { stepId: step.id, field: "id" },
+        message: `Step ID '${step.id}' is invalid — must match [a-zA-Z_][a-zA-Z0-9_]* (use underscores, not hyphens)`,
+        code: "INVALID_STEP_ID"
+      });
+    }
+  }
+  const stepIdSet = new Set(workflow.steps.map((s) => s.id));
+  for (const step of workflow.steps) {
+    if (step.type === "for-each") {
+      const { itemName } = step.params;
+      if (!VALID_STEP_ID.test(itemName)) {
+        diagnostics.push({
+          severity: "error",
+          location: { stepId: step.id, field: "params.itemName" },
+          message: `Item name '${itemName}' is invalid — must match [a-zA-Z_][a-zA-Z0-9_]*`,
+          code: "INVALID_ITEM_NAME"
+        });
+      }
+      if (stepIdSet.has(itemName)) {
+        diagnostics.push({
+          severity: "warning",
+          location: { stepId: step.id, field: "params.itemName" },
+          message: `Item name '${itemName}' shadows step ID '${itemName}' — references to '${itemName}' inside the loop body will resolve to the loop variable, not the step output`,
+          code: "ITEM_NAME_SHADOWS_STEP_ID"
+        });
+      }
+    }
+  }
+  const { index: stepIndex, duplicates } = buildStepIndex(workflow.steps);
+  for (const dupId of duplicates) {
+    diagnostics.push({
+      severity: "error",
+      location: { stepId: dupId, field: "id" },
+      message: `Duplicate step ID '${dupId}'`,
+      code: "DUPLICATE_STEP_ID"
+    });
+  }
+  if (!stepIndex.has(workflow.initialStepId)) {
+    diagnostics.push({
+      severity: "error",
+      location: { stepId: null, field: "initialStepId" },
+      message: `Initial step '${workflow.initialStepId}' does not exist`,
+      code: "MISSING_INITIAL_STEP"
+    });
+    return { graph: null, diagnostics };
+  }
+  if (duplicates.length > 0) {
+    return { graph: null, diagnostics };
+  }
+  const successors = computeSuccessors(stepIndex);
+  const cycles = detectCycles(stepIndex, successors);
+  for (const cycle of cycles) {
+    const firstStep = cycle[0];
+    if (!firstStep)
+      continue;
+    diagnostics.push({
+      severity: "error",
+      location: { stepId: firstStep, field: "nextStepId" },
+      message: `Cycle detected: ${cycle.join(" → ")} → ${firstStep}`,
+      code: "CYCLE_DETECTED"
+    });
+  }
+  const reachableSteps = computeReachability(workflow.initialStepId, successors);
+  for (const [id] of stepIndex) {
+    if (!reachableSteps.has(id)) {
+      diagnostics.push({
+        severity: "warning",
+        location: { stepId: id, field: "id" },
+        message: `Step '${id}' is not reachable from initial step '${workflow.initialStepId}'`,
+        code: "UNREACHABLE_STEP"
+      });
+    }
+  }
+  if (cycles.length > 0) {
+    return { graph: null, diagnostics };
+  }
+  const reachableIds = [...reachableSteps];
+  const topologicalOrder = topologicalSort(reachableIds, successors);
+  if (!topologicalOrder) {
+    return { graph: null, diagnostics };
+  }
+  const predecessors = computePredecessors(topologicalOrder, successors);
+  const { loopVariablesInScope, bodyOwnership } = computeLoopScopesAndOwnership(workflow.initialStepId, stepIndex);
+  return {
+    graph: {
+      stepIndex,
+      successors,
+      predecessors,
+      topologicalOrder,
+      reachableSteps,
+      loopVariablesInScope,
+      bodyOwnership
+    },
+    diagnostics
+  };
+}
+
+// src/compiler/passes/generate-constrained-tool-schemas.ts
+function collectCallSites(workflow) {
+  const callSitesByTool = new Map;
+  for (const step of workflow.steps) {
+    if (step.type !== "tool-call")
+      continue;
+    const { toolName, toolInput } = step.params;
+    const keys = new Map;
+    for (const [key, expr] of Object.entries(toolInput)) {
+      const expression = expr;
+      if (expression.type === "literal") {
+        keys.set(key, { type: "literal", value: expression.value });
+      } else {
+        keys.set(key, { type: "jmespath" });
+      }
+    }
+    let sites = callSitesByTool.get(toolName);
+    if (!sites) {
+      sites = [];
+      callSitesByTool.set(toolName, sites);
+    }
+    sites.push({ stepId: step.id, keys });
+  }
+  return callSitesByTool;
+}
+function constrainProperty(callSites, key, originalPropertySchema) {
+  let providedCount = 0;
+  let allLiteral = true;
+  const literalValues = [];
+  const seen = new Set;
+  for (const site of callSites) {
+    const entry = site.keys.get(key);
+    if (!entry)
+      continue;
+    providedCount++;
+    if (entry.type === "jmespath") {
+      allLiteral = false;
+    } else {
+      const serialized = JSON.stringify(entry.value);
+      if (!seen.has(serialized)) {
+        seen.add(serialized);
+        literalValues.push(entry.value);
+      }
+    }
+  }
+  const providedInAll = providedCount === callSites.length;
+  if (!allLiteral) {
+    return { schema: originalPropertySchema, allLiteral: false, providedInAll };
+  }
+  const original = originalPropertySchema && typeof originalPropertySchema === "object" ? originalPropertySchema : {};
+  if (literalValues.length === 1) {
+    return {
+      schema: { ...original, const: literalValues[0] },
+      allLiteral: true,
+      providedInAll
+    };
+  }
+  return {
+    schema: { ...original, enum: literalValues },
+    allLiteral: true,
+    providedInAll
+  };
+}
+function generateConstrainedToolSchemas(workflow, tools) {
+  const callSitesByTool = collectCallSites(workflow);
+  const result = {};
+  for (const [toolName, callSites] of callSitesByTool) {
+    const toolDef = tools[toolName];
+    if (!toolDef)
+      continue;
+    const originalProperties = toolDef.inputSchema.properties ?? {};
+    const allUsedKeys = new Set;
+    for (const site of callSites) {
+      for (const key of site.keys.keys()) {
+        allUsedKeys.add(key);
+      }
+    }
+    const constrainedProperties = {};
+    const requiredKeys = [];
+    let fullyStatic = true;
+    for (const key of allUsedKeys) {
+      const originalProp = originalProperties[key];
+      if (originalProp === undefined)
+        continue;
+      const { schema, allLiteral, providedInAll } = constrainProperty(callSites, key, originalProp);
+      constrainedProperties[key] = schema;
+      if (providedInAll) {
+        requiredKeys.push(key);
+      }
+      if (!allLiteral) {
+        fullyStatic = false;
+      }
+    }
+    const constrained = {
+      inputSchema: {
+        required: requiredKeys.sort(),
+        properties: constrainedProperties
+      },
+      fullyStatic,
+      callSites: callSites.map((s) => s.stepId).sort()
+    };
+    if (toolDef.outputSchema) {
+      constrained.outputSchema = toolDef.outputSchema;
+    }
+    result[toolName] = constrained;
+  }
+  for (const step of workflow.steps) {
+    if (step.type !== "agent-loop")
+      continue;
+    for (const toolName of step.params.tools) {
+      if (result[toolName]) {
+        result[toolName].fullyStatic = false;
+        if (!result[toolName].callSites.includes(step.id)) {
+          result[toolName].callSites.push(step.id);
+          result[toolName].callSites.sort();
+        }
+      } else if (tools[toolName]) {
+        const toolDef = tools[toolName];
+        const constrained = {
+          inputSchema: {
+            required: [],
+            properties: {}
+          },
+          fullyStatic: false,
+          callSites: [step.id]
+        };
+        if (toolDef.outputSchema) {
+          constrained.outputSchema = toolDef.outputSchema;
+        }
+        result[toolName] = constrained;
+      }
+    }
+  }
+  return result;
+}
+
+// src/compiler/utils/schema.ts
+function parseSimplePath(expression) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*$/.test(expression)) {
+    return null;
+  }
+  return expression.split(".");
+}
+function resolvePath(schema, path) {
+  let current = schema;
+  for (const segment of path) {
+    const properties = current.properties;
+    if (!properties?.[segment])
+      return null;
+    current = properties[segment];
+  }
+  return current;
+}
+function getSchemaType(schema) {
+  if (typeof schema.type === "string")
+    return schema.type;
+  return null;
+}
+function findArrayProperties(schema) {
+  const properties = schema.properties;
+  if (!properties)
+    return [];
+  return Object.entries(properties).filter(([_, propSchema]) => propSchema.type === "array").map(([name]) => name);
+}
+function getStepOutputSchema(step, tools, workflow, graph) {
+  switch (step.type) {
+    case "tool-call": {
+      if (!tools)
+        return null;
+      const toolDef = tools[step.params.toolName];
+      return toolDef?.outputSchema ?? null;
+    }
+    case "llm-prompt":
+    case "extract-data":
+    case "agent-loop":
+      return step.params.outputFormat ?? null;
+    case "for-each": {
+      const bodyItemSchema = resolveChainOutputSchema(step.params.loopBodyStepId, tools, workflow, graph);
+      if (!bodyItemSchema)
+        return null;
+      return { type: "array", items: bodyItemSchema };
+    }
+    case "switch-case":
+      return null;
+    case "start":
+      return null;
+    case "end":
+      return null;
+    default:
+      return null;
+  }
+}
+function resolveChainOutputSchema(startId, tools, workflow, graph) {
+  let currentId = startId;
+  const visited = new Set;
+  while (currentId) {
+    if (visited.has(currentId))
+      break;
+    visited.add(currentId);
+    const step = graph.stepIndex.get(currentId);
+    if (!step)
+      break;
+    if (!step.nextStepId) {
+      return getStepOutputSchema(step, tools, workflow, graph);
+    }
+    currentId = step.nextStepId;
+  }
+  return null;
+}
+function resolveExpressionSchema(expression, _endStepId, tools, workflow, graph) {
+  const segments = parseSimplePath(expression);
+  if (!segments)
+    return null;
+  const [rootId, ...fieldPath] = segments;
+  if (!rootId)
+    return null;
+  let rootSchema = null;
+  if (rootId === "input" && workflow.inputSchema) {
+    rootSchema = workflow.inputSchema;
+  } else {
+    const referencedStep = graph.stepIndex.get(rootId);
+    if (!referencedStep)
+      return null;
+    rootSchema = getStepOutputSchema(referencedStep, tools, workflow, graph);
+  }
+  if (!rootSchema)
+    return null;
+  if (fieldPath.length === 0)
+    return rootSchema;
+  return resolvePath(rootSchema, fieldPath);
+}
+
+// src/compiler/passes/validate-control-flow.ts
+function validateControlFlow(workflow, graph, tools) {
+  const diagnostics = [];
+  for (const step of workflow.steps) {
+    if (step.type === "end" && step.nextStepId) {
+      diagnostics.push({
+        severity: "error",
+        location: { stepId: step.id, field: "nextStepId" },
+        message: `End step '${step.id}' should not have a nextStepId`,
+        code: "END_STEP_HAS_NEXT"
+      });
+    }
+    if (step.type === "switch-case") {
+      const defaultCount = step.params.cases.filter((c) => c.value.type === "default").length;
+      if (defaultCount > 1) {
+        diagnostics.push({
+          severity: "error",
+          location: { stepId: step.id, field: "params.cases" },
+          message: `Switch-case step '${step.id}' has ${defaultCount} default cases (expected at most 1)`,
+          code: "MULTIPLE_DEFAULT_CASES"
+        });
+      }
+      for (const [i, c] of step.params.cases.entries()) {
+        const escapes = checkBodyEscapes(c.branchBodyStepId, step.id, graph);
+        if (escapes) {
+          diagnostics.push({
+            severity: "warning",
+            location: {
+              stepId: step.id,
+              field: `params.cases[${i}].branchBodyStepId`
+            },
+            message: `Branch body starting at '${c.branchBodyStepId}' in step '${step.id}' has a step ('${escapes.escapingStep}') whose nextStepId points outside the branch body to '${escapes.target}'`,
+            code: "BRANCH_BODY_ESCAPES"
+          });
+        }
+      }
+    }
+    if (step.type === "for-each") {
+      const escapes = checkBodyEscapes(step.params.loopBodyStepId, step.id, graph);
+      if (escapes) {
+        diagnostics.push({
+          severity: "warning",
+          location: {
+            stepId: step.id,
+            field: "params.loopBodyStepId"
+          },
+          message: `Loop body starting at '${step.params.loopBodyStepId}' in step '${step.id}' has a step ('${escapes.escapingStep}') whose nextStepId points outside the loop body to '${escapes.target}'`,
+          code: "LOOP_BODY_ESCAPES"
+        });
+      }
+    }
+    if (step.type === "wait-for-condition") {
+      const escapes = checkBodyEscapes(step.params.conditionStepId, step.id, graph);
+      if (escapes) {
+        diagnostics.push({
+          severity: "warning",
+          location: {
+            stepId: step.id,
+            field: "params.conditionStepId"
+          },
+          message: `Condition body starting at '${step.params.conditionStepId}' in step '${step.id}' has a step ('${escapes.escapingStep}') whose nextStepId points outside the condition body to '${escapes.target}'`,
+          code: "CONDITION_BODY_ESCAPES"
+        });
+      }
+    }
+  }
+  if (workflow.outputSchema) {
+    const outputPoints = findWorkflowOutputPoints(workflow.initialStepId, graph);
+    for (const point of outputPoints) {
+      if (point.type === "missing_end") {
+        diagnostics.push({
+          severity: "error",
+          location: { stepId: point.stepId, field: "nextStepId" },
+          message: `Step '${point.stepId}' is a terminal step but is not an end step; all execution paths must terminate at an end step when outputSchema is declared`,
+          code: "PATH_MISSING_END_STEP"
+        });
+      } else if (point.type === "end_without_output") {
+        diagnostics.push({
+          severity: "error",
+          location: { stepId: point.stepId, field: "params" },
+          message: `End step '${point.stepId}' has no output expression, but the workflow declares an outputSchema`,
+          code: "END_STEP_MISSING_OUTPUT"
+        });
+      } else if (point.type === "end_with_output") {
+        const step = graph.stepIndex.get(point.stepId);
+        if (step?.type === "end" && step.params?.output) {
+          const expr = step.params.output;
+          const outputSchema = workflow.outputSchema;
+          if (expr.type === "literal") {
+            diagnostics.push(...validateOutputShapeMismatch(expr.value, outputSchema, point.stepId));
+          } else if (expr.type === "jmespath") {
+            const resolvedSchema = resolveExpressionSchema(expr.expression, point.stepId, tools ?? null, workflow, graph);
+            if (resolvedSchema) {
+              diagnostics.push(...validateSchemaCompatibility(resolvedSchema, outputSchema, point.stepId, expr.expression));
+            }
+          }
+        }
+      }
+    }
+  } else {
+    for (const step of workflow.steps) {
+      if (step.type === "end" && step.params?.output) {
+        diagnostics.push({
+          severity: "warning",
+          location: { stepId: step.id, field: "params.output" },
+          message: `End step '${step.id}' has an output expression, but the workflow does not declare an outputSchema`,
+          code: "END_STEP_UNEXPECTED_OUTPUT"
+        });
+      }
+    }
+  }
+  return diagnostics;
+}
+function checkBodyEscapes(startId, parentStepId, graph) {
+  let currentId = startId;
+  const visited = new Set;
+  while (currentId) {
+    if (visited.has(currentId))
+      break;
+    visited.add(currentId);
+    const step = graph.stepIndex.get(currentId);
+    if (!step)
+      break;
+    if (step.nextStepId) {
+      const nextOwner = graph.bodyOwnership.get(step.nextStepId);
+      const currentOwner = graph.bodyOwnership.get(currentId);
+      if ((currentOwner === parentStepId || currentId === startId) && nextOwner !== parentStepId) {
+        return { escapingStep: currentId, target: step.nextStepId };
+      }
+    }
+    currentId = step.nextStepId;
+  }
+  return null;
+}
+function findWorkflowOutputPoints(startId, graph) {
+  return collectOutputPoints(startId, graph, new Set);
+}
+function collectOutputPoints(startId, graph, visited) {
+  const points = [];
+  let currentId = startId;
+  while (currentId) {
+    if (visited.has(currentId))
+      break;
+    visited.add(currentId);
+    const step = graph.stepIndex.get(currentId);
+    if (!step)
+      break;
+    if (!step.nextStepId) {
+      if (step.type === "end") {
+        points.push({
+          type: step.params?.output ? "end_with_output" : "end_without_output",
+          stepId: step.id
+        });
+      } else if (step.type === "switch-case") {
+        for (const c of step.params.cases) {
+          points.push(...collectOutputPoints(c.branchBodyStepId, graph, visited));
+        }
+      } else if (step.type === "for-each") {
+        points.push(...collectOutputPoints(step.params.loopBodyStepId, graph, visited));
+      } else {
+        points.push({ type: "missing_end", stepId: step.id });
+      }
+      break;
+    }
+    currentId = step.nextStepId;
+  }
+  return points;
+}
+function validateOutputShapeMismatch(value, schema, stepId) {
+  const diagnostics = [];
+  const expectedType = schema.type;
+  if (typeof expectedType !== "string")
+    return diagnostics;
+  const actualType = getValueType(value);
+  if (expectedType !== actualType) {
+    diagnostics.push({
+      severity: "error",
+      location: { stepId, field: "params.output" },
+      message: `End step '${stepId}' output literal has type '${actualType}' but outputSchema expects '${expectedType}'`,
+      code: "LITERAL_OUTPUT_SHAPE_MISMATCH"
+    });
+    return diagnostics;
+  }
+  if (expectedType === "object" && typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const obj = value;
+    const required = schema.required;
+    if (Array.isArray(required)) {
+      const missing = required.filter((key) => typeof key === "string" && !(key in obj));
+      if (missing.length > 0) {
+        diagnostics.push({
+          severity: "error",
+          location: { stepId, field: "params.output" },
+          message: `End step '${stepId}' output literal is missing required field(s): ${missing.join(", ")}`,
+          code: "LITERAL_OUTPUT_SHAPE_MISMATCH"
+        });
+      }
+    }
+    const properties = schema.properties;
+    if (properties && typeof properties === "object") {
+      for (const [key, val] of Object.entries(obj)) {
+        const propSchema = properties[key];
+        if (propSchema && typeof propSchema === "object" && "type" in propSchema) {
+          const propExpected = propSchema.type;
+          const propActual = getValueType(val);
+          if (propExpected !== propActual) {
+            diagnostics.push({
+              severity: "error",
+              location: { stepId, field: "params.output" },
+              message: `End step '${stepId}' output literal field '${key}' has type '${propActual}' but schema expects '${propExpected}'`,
+              code: "LITERAL_OUTPUT_SHAPE_MISMATCH"
+            });
+          }
+        }
+      }
+    }
+  }
+  return diagnostics;
+}
+function getValueType(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  return typeof value;
+}
+function validateSchemaCompatibility(resolvedSchema, outputSchema, stepId, expression) {
+  const diagnostics = [];
+  const expectedType = outputSchema.type;
+  const resolvedType = resolvedSchema.type;
+  if (typeof expectedType !== "string" || typeof resolvedType !== "string") {
+    return diagnostics;
+  }
+  if (expectedType !== resolvedType) {
+    diagnostics.push({
+      severity: "error",
+      location: { stepId, field: "params.output" },
+      message: `End step '${stepId}' output expression '${expression}' resolves to type '${resolvedType}' but outputSchema expects '${expectedType}'`,
+      code: "LITERAL_OUTPUT_SHAPE_MISMATCH"
+    });
+    return diagnostics;
+  }
+  if (expectedType === "object") {
+    const expectedRequired = outputSchema.required;
+    const resolvedProps = resolvedSchema.properties ?? {};
+    if (Array.isArray(expectedRequired)) {
+      const missing = expectedRequired.filter((key) => typeof key === "string" && !(key in resolvedProps));
+      if (missing.length > 0) {
+        diagnostics.push({
+          severity: "error",
+          location: { stepId, field: "params.output" },
+          message: `End step '${stepId}' output expression '${expression}' schema is missing required field(s): ${missing.join(", ")}`,
+          code: "LITERAL_OUTPUT_SHAPE_MISMATCH"
+        });
+      }
+    }
+    const expectedProps = outputSchema.properties ?? {};
+    for (const [key, expectedPropSchema] of Object.entries(expectedProps)) {
+      const resolvedPropSchema = resolvedProps[key];
+      if (!resolvedPropSchema)
+        continue;
+      const expectedPropType = expectedPropSchema.type;
+      const resolvedPropType = resolvedPropSchema.type;
+      if (typeof expectedPropType === "string" && typeof resolvedPropType === "string" && expectedPropType !== resolvedPropType) {
+        diagnostics.push({
+          severity: "error",
+          location: { stepId, field: "params.output" },
+          message: `End step '${stepId}' output expression '${expression}' field '${key}' has type '${resolvedPropType}' but outputSchema expects '${expectedPropType}'`,
+          code: "LITERAL_OUTPUT_SHAPE_MISMATCH"
+        });
+      }
+    }
+  }
+  return diagnostics;
+}
+
+// src/compiler/passes/validate-foreach-target.ts
+function validateForeachTarget(workflow, graph, tools) {
+  const diagnostics = [];
+  for (const step of workflow.steps) {
+    if (step.type !== "for-each")
+      continue;
+    if (step.params.target.type !== "jmespath")
+      continue;
+    const expression = step.params.target.expression;
+    const segments = parseSimplePath(expression);
+    if (!segments)
+      continue;
+    const [rootId, ...fieldPath] = segments;
+    if (!rootId)
+      continue;
+    let outputSchema = null;
+    if (rootId === "input" && workflow.inputSchema) {
+      outputSchema = workflow.inputSchema;
+    } else {
+      const referencedStep = graph.stepIndex.get(rootId);
+      if (!referencedStep)
+        continue;
+      outputSchema = getStepOutputSchema(referencedStep, tools, workflow, graph);
+    }
+    if (!outputSchema)
+      continue;
+    const resolvedSchema = resolvePath(outputSchema, fieldPath);
+    if (!resolvedSchema)
+      continue;
+    const resolvedType = getSchemaType(resolvedSchema);
+    if (resolvedType === "array")
+      continue;
+    if (resolvedType === "object") {
+      const suggestions = findArrayProperties(resolvedSchema);
+      const hint = suggestions.length > 0 ? ` Did you mean ${suggestions.map((s) => `'${rootId}.${s}'`).join(" or ")}?` : "";
+      diagnostics.push({
+        severity: "error",
+        location: { stepId: step.id, field: "params.target" },
+        message: `for-each target '${expression}' resolves to an object, not an array.${hint}`,
+        code: "FOREACH_TARGET_NOT_ARRAY"
+      });
+    } else if (resolvedType !== null) {
+      diagnostics.push({
+        severity: "error",
+        location: { stepId: step.id, field: "params.target" },
+        message: `for-each target '${expression}' resolves to type '${resolvedType}', not an array.`,
+        code: "FOREACH_TARGET_NOT_ARRAY"
+      });
+    }
+  }
+  return diagnostics;
+}
+
+// src/compiler/utils/jmespath-helpers.ts
+import { compile } from "@jmespath-community/jmespath";
+function validateJmespathSyntax(expression) {
+  try {
+    compile(expression);
+    return { valid: true };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+}
+function extractRootIdentifiers(expression) {
+  let ast;
+  try {
+    ast = compile(expression);
+  } catch {
+    return [];
+  }
+  const roots = new Set;
+  collectRoots(ast, roots);
+  return [...roots];
+}
+function collectRoots(node, roots) {
+  if (!node || typeof node !== "object")
+    return;
+  switch (node.type) {
+    case "Field":
+      if (node.name)
+        roots.add(node.name);
+      break;
+    case "Subexpression":
+      if (node.left)
+        collectLeftmostRoot(node.left, roots);
+      break;
+    case "FilterProjection":
+      if (node.left)
+        collectLeftmostRoot(node.left, roots);
+      break;
+    case "Projection":
+    case "Flatten":
+      if (node.left)
+        collectLeftmostRoot(node.left, roots);
+      break;
+    case "Function":
+      if (node.children) {
+        for (const child of node.children) {
+          collectRoots(child, roots);
+        }
+      }
+      break;
+    case "MultiSelectList":
+    case "MultiSelectHash":
+      if (node.children) {
+        for (const child of node.children) {
+          collectRoots(child, roots);
+        }
+      }
+      break;
+    case "Comparator":
+    case "And":
+    case "Or":
+    case "Arithmetic":
+      if (node.left)
+        collectRoots(node.left, roots);
+      if (node.right)
+        collectRoots(node.right, roots);
+      break;
+    case "Not":
+    case "Negate":
+      if (node.children?.[0])
+        collectRoots(node.children[0], roots);
+      break;
+    case "Pipe":
+      if (node.left)
+        collectRoots(node.left, roots);
+      break;
+    case "IndexExpression":
+      if (node.left)
+        collectLeftmostRoot(node.left, roots);
+      break;
+    case "ValueProjection":
+    case "Slice":
+      if (node.left)
+        collectLeftmostRoot(node.left, roots);
+      break;
+    case "Literal":
+    case "Current":
+    case "Identity":
+    case "Expref":
+      break;
+    case "KeyValuePair": {
+      const kvValue = node.value;
+      if (kvValue) {
+        collectRoots(kvValue, roots);
+      }
+      break;
+    }
+    default:
+      if (node.left)
+        collectRoots(node.left, roots);
+      if (node.right)
+        collectRoots(node.right, roots);
+      if (node.children) {
+        for (const child of node.children) {
+          collectRoots(child, roots);
+        }
+      }
+      break;
+  }
+}
+function collectLeftmostRoot(node, roots) {
+  if (!node)
+    return;
+  switch (node.type) {
+    case "Field":
+      if (node.name)
+        roots.add(node.name);
+      break;
+    case "Subexpression":
+      if (node.left)
+        collectLeftmostRoot(node.left, roots);
+      break;
+    case "FilterProjection":
+    case "Projection":
+    case "Flatten":
+    case "IndexExpression":
+    case "ValueProjection":
+    case "Slice":
+      if (node.left)
+        collectLeftmostRoot(node.left, roots);
+      break;
+    default:
+      collectRoots(node, roots);
+      break;
+  }
+}
+function extractTemplateExpressions(template) {
+  const expressions = [];
+  const unclosed = [];
+  let i = 0;
+  while (i < template.length) {
+    if (template[i] === "$" && template[i + 1] === "{") {
+      const start = i;
+      i += 2;
+      let depth = 1;
+      const exprStart = i;
+      while (i < template.length && depth > 0) {
+        if (template[i] === "{")
+          depth++;
+        else if (template[i] === "}")
+          depth--;
+        if (depth > 0)
+          i++;
+      }
+      if (depth === 0) {
+        const expression = template.slice(exprStart, i);
+        expressions.push({ expression, start, end: i + 1 });
+        i++;
+      } else {
+        unclosed.push(start);
+      }
+    } else {
+      i++;
+    }
+  }
+  return { expressions, unclosed };
+}
+
+// src/compiler/passes/validate-jmespath.ts
+function validateJmespath(workflow, graph) {
+  const diagnostics = [];
+  const { expressions, templateDiagnostics } = collectExpressions(workflow);
+  diagnostics.push(...templateDiagnostics);
+  for (const expr of expressions) {
+    const syntaxResult = validateJmespathSyntax(expr.expression);
+    if (!syntaxResult.valid) {
+      diagnostics.push({
+        severity: "error",
+        location: { stepId: expr.stepId, field: expr.field },
+        message: `Invalid JMESPath syntax in '${expr.expression}': ${syntaxResult.error}`,
+        code: "JMESPATH_SYNTAX_ERROR"
+      });
+      continue;
+    }
+    validateExpressionScope(expr, graph, !!workflow.inputSchema, diagnostics);
+  }
+  return diagnostics;
+}
+function collectFromExpressionValue(val, stepId, field, expressions, templateDiagnostics) {
+  if (val.type === "jmespath" && val.expression) {
+    expressions.push({
+      expression: val.expression,
+      stepId,
+      field: `${field}.expression`
+    });
+  } else if (val.type === "template" && val.template) {
+    const { expressions: templateExprs, unclosed } = extractTemplateExpressions(val.template);
+    for (const te of templateExprs) {
+      expressions.push({
+        expression: te.expression,
+        stepId,
+        field: `${field}.template[${te.start}:${te.end}]`
+      });
+    }
+    for (const pos of unclosed) {
+      templateDiagnostics.push({
+        severity: "error",
+        location: { stepId, field: `${field}.template[${pos}]` },
+        message: `Unclosed template expression at position ${pos} in template`,
+        code: "UNCLOSED_TEMPLATE_EXPRESSION"
+      });
+    }
+  }
+}
+function collectExpressions(workflow) {
+  const expressions = [];
+  const templateDiagnostics = [];
+  for (const step of workflow.steps) {
+    switch (step.type) {
+      case "tool-call":
+        for (const [key, val] of Object.entries(step.params.toolInput)) {
+          collectFromExpressionValue(val, step.id, `params.toolInput.${key}`, expressions, templateDiagnostics);
+        }
+        break;
+      case "switch-case":
+        collectFromExpressionValue(step.params.switchOn, step.id, "params.switchOn", expressions, templateDiagnostics);
+        for (const [i, c] of step.params.cases.entries()) {
+          collectFromExpressionValue(c.value, step.id, `params.cases[${i}].value`, expressions, templateDiagnostics);
+        }
+        break;
+      case "for-each":
+        collectFromExpressionValue(step.params.target, step.id, "params.target", expressions, templateDiagnostics);
+        break;
+      case "extract-data":
+        collectFromExpressionValue(step.params.sourceData, step.id, "params.sourceData", expressions, templateDiagnostics);
+        break;
+      case "start":
+        break;
+      case "end":
+        if (step.params?.output) {
+          collectFromExpressionValue(step.params.output, step.id, "params.output", expressions, templateDiagnostics);
+        }
+        break;
+      case "llm-prompt": {
+        const { expressions: templateExprs, unclosed } = extractTemplateExpressions(step.params.prompt);
+        for (const te of templateExprs) {
+          expressions.push({
+            expression: te.expression,
+            stepId: step.id,
+            field: `params.prompt[${te.start}:${te.end}]`
+          });
+        }
+        for (const pos of unclosed) {
+          templateDiagnostics.push({
+            severity: "error",
+            location: {
+              stepId: step.id,
+              field: `params.prompt[${pos}]`
+            },
+            message: `Unclosed template expression at position ${pos} in prompt`,
+            code: "UNCLOSED_TEMPLATE_EXPRESSION"
+          });
+        }
+        break;
+      }
+      case "agent-loop": {
+        const { expressions: templateExprs, unclosed } = extractTemplateExpressions(step.params.instructions);
+        for (const te of templateExprs) {
+          expressions.push({
+            expression: te.expression,
+            stepId: step.id,
+            field: `params.instructions[${te.start}:${te.end}]`
+          });
+        }
+        for (const pos of unclosed) {
+          templateDiagnostics.push({
+            severity: "error",
+            location: {
+              stepId: step.id,
+              field: `params.instructions[${pos}]`
+            },
+            message: `Unclosed template expression at position ${pos} in instructions`,
+            code: "UNCLOSED_TEMPLATE_EXPRESSION"
+          });
+        }
+        if (step.params.maxSteps) {
+          collectFromExpressionValue(step.params.maxSteps, step.id, "params.maxSteps", expressions, templateDiagnostics);
+        }
+        break;
+      }
+    }
+  }
+  return { expressions, templateDiagnostics };
+}
+function validateExpressionScope(expr, graph, hasInputSchema, diagnostics) {
+  const astRoots = extractRootIdentifiers(expr.expression);
+  const loopVars = graph.loopVariablesInScope.get(expr.stepId);
+  const predecessors = graph.predecessors.get(expr.stepId);
+  for (const root of astRoots) {
+    if (root === "input" && hasInputSchema)
+      continue;
+    if (loopVars?.has(root))
+      continue;
+    if (graph.stepIndex.has(root)) {
+      if (predecessors && !predecessors.has(root)) {
+        diagnostics.push({
+          severity: "warning",
+          location: { stepId: expr.stepId, field: expr.field },
+          message: `Expression '${expr.expression}' references step '${root}' which may not have executed before step '${expr.stepId}'`,
+          code: "JMESPATH_FORWARD_REFERENCE"
+        });
+      }
+      continue;
+    }
+    diagnostics.push({
+      severity: "error",
+      location: { stepId: expr.stepId, field: expr.field },
+      message: `Expression '${expr.expression}' references '${root}' which is not a known step ID or loop variable in scope`,
+      code: "JMESPATH_INVALID_ROOT_REFERENCE"
+    });
+  }
+}
+
+// src/compiler/passes/validate-limits.ts
+var DEFAULT_LIMITS = {
+  maxAttempts: Number.POSITIVE_INFINITY,
+  maxSleepMs: 300000,
+  maxBackoffMultiplier: 2,
+  minBackoffMultiplier: 1,
+  maxTimeoutMs: 600000
+};
+function validateLimits(workflow, limits) {
+  const resolved = { ...DEFAULT_LIMITS, ...limits };
+  const diagnostics = [];
+  for (const step of workflow.steps) {
+    if (step.type === "sleep") {
+      const expr = step.params.durationMs;
+      if (expr.type === "literal" && typeof expr.value === "number") {
+        if (expr.value > resolved.maxSleepMs) {
+          diagnostics.push({
+            severity: "error",
+            location: { stepId: step.id, field: "params.durationMs" },
+            message: `Sleep duration ${expr.value}ms exceeds limit of ${resolved.maxSleepMs}ms`,
+            code: "SLEEP_DURATION_EXCEEDS_LIMIT"
+          });
+        }
+      }
+    }
+    if (step.type === "wait-for-condition") {
+      const { maxAttempts, intervalMs, backoffMultiplier, timeoutMs } = step.params;
+      if (maxAttempts?.type === "literal" && typeof maxAttempts.value === "number") {
+        if (maxAttempts.value > resolved.maxAttempts) {
+          diagnostics.push({
+            severity: "error",
+            location: { stepId: step.id, field: "params.maxAttempts" },
+            message: `maxAttempts ${maxAttempts.value} exceeds limit of ${resolved.maxAttempts}`,
+            code: "WAIT_ATTEMPTS_EXCEEDS_LIMIT"
+          });
+        }
+      }
+      if (intervalMs?.type === "literal" && typeof intervalMs.value === "number") {
+        if (intervalMs.value > resolved.maxSleepMs) {
+          diagnostics.push({
+            severity: "error",
+            location: { stepId: step.id, field: "params.intervalMs" },
+            message: `intervalMs ${intervalMs.value}ms exceeds limit of ${resolved.maxSleepMs}ms`,
+            code: "WAIT_INTERVAL_EXCEEDS_LIMIT"
+          });
+        }
+      }
+      if (backoffMultiplier?.type === "literal" && typeof backoffMultiplier.value === "number") {
+        if (backoffMultiplier.value < resolved.minBackoffMultiplier || backoffMultiplier.value > resolved.maxBackoffMultiplier) {
+          diagnostics.push({
+            severity: "error",
+            location: { stepId: step.id, field: "params.backoffMultiplier" },
+            message: `backoffMultiplier ${backoffMultiplier.value} is outside allowed range [${resolved.minBackoffMultiplier}, ${resolved.maxBackoffMultiplier}]`,
+            code: "BACKOFF_MULTIPLIER_OUT_OF_RANGE"
+          });
+        }
+      }
+      if (timeoutMs?.type === "literal" && typeof timeoutMs.value === "number") {
+        if (timeoutMs.value > resolved.maxTimeoutMs) {
+          diagnostics.push({
+            severity: "error",
+            location: { stepId: step.id, field: "params.timeoutMs" },
+            message: `timeoutMs ${timeoutMs.value}ms exceeds limit of ${resolved.maxTimeoutMs}ms`,
+            code: "WAIT_TIMEOUT_EXCEEDS_LIMIT"
+          });
+        }
+      }
+    }
+  }
+  return diagnostics;
+}
+
+// src/compiler/passes/validate-references.ts
+function validateReferences(workflow) {
+  const diagnostics = [];
+  const stepIds = new Set(workflow.steps.map((s) => s.id));
+  if (!stepIds.has(workflow.initialStepId)) {
+    diagnostics.push({
+      severity: "error",
+      location: { stepId: null, field: "initialStepId" },
+      message: `Initial step '${workflow.initialStepId}' does not exist`,
+      code: "MISSING_INITIAL_STEP"
+    });
+  }
+  for (const step of workflow.steps) {
+    if (step.nextStepId && !stepIds.has(step.nextStepId)) {
+      diagnostics.push({
+        severity: "error",
+        location: { stepId: step.id, field: "nextStepId" },
+        message: `Step '${step.id}' references non-existent next step '${step.nextStepId}'`,
+        code: "MISSING_NEXT_STEP"
+      });
+    }
+    if (step.type === "switch-case") {
+      for (const [i, c] of step.params.cases.entries()) {
+        if (!stepIds.has(c.branchBodyStepId)) {
+          diagnostics.push({
+            severity: "error",
+            location: {
+              stepId: step.id,
+              field: `params.cases[${i}].branchBodyStepId`
+            },
+            message: `Step '${step.id}' case ${i} references non-existent branch body step '${c.branchBodyStepId}'`,
+            code: "MISSING_BRANCH_BODY_STEP"
+          });
+        }
+      }
+    }
+    if (step.type === "for-each") {
+      if (!stepIds.has(step.params.loopBodyStepId)) {
+        diagnostics.push({
+          severity: "error",
+          location: {
+            stepId: step.id,
+            field: "params.loopBodyStepId"
+          },
+          message: `Step '${step.id}' references non-existent loop body step '${step.params.loopBodyStepId}'`,
+          code: "MISSING_LOOP_BODY_STEP"
+        });
+      }
+    }
+    if (step.type === "wait-for-condition") {
+      if (!stepIds.has(step.params.conditionStepId)) {
+        diagnostics.push({
+          severity: "error",
+          location: {
+            stepId: step.id,
+            field: "params.conditionStepId"
+          },
+          message: `Step '${step.id}' references non-existent condition body step '${step.params.conditionStepId}'`,
+          code: "MISSING_CONDITION_BODY_STEP"
+        });
+      }
+    }
+  }
+  return diagnostics;
+}
+
+// src/compiler/passes/validate-tools.ts
+function validateTools(workflow, tools) {
+  const diagnostics = [];
+  for (const step of workflow.steps) {
+    if (step.type === "tool-call") {
+      const { toolName, toolInput } = step.params;
+      const toolDef = tools[toolName];
+      if (!toolDef) {
+        diagnostics.push({
+          severity: "error",
+          location: { stepId: step.id, field: "params.toolName" },
+          message: `Step '${step.id}' references unknown tool '${toolName}'`,
+          code: "UNKNOWN_TOOL"
+        });
+        continue;
+      }
+      const schemaProperties = toolDef.inputSchema.properties ?? {};
+      const requiredKeys = new Set(toolDef.inputSchema.required ?? []);
+      const definedKeys = new Set(Object.keys(schemaProperties));
+      const providedKeys = new Set(Object.keys(toolInput));
+      for (const key of providedKeys) {
+        if (!definedKeys.has(key)) {
+          diagnostics.push({
+            severity: "warning",
+            location: {
+              stepId: step.id,
+              field: `params.toolInput.${key}`
+            },
+            message: `Step '${step.id}' provides input key '${key}' which is not defined in tool '${toolName}' schema`,
+            code: "EXTRA_TOOL_INPUT_KEY"
+          });
+        }
+      }
+      for (const key of requiredKeys) {
+        if (!providedKeys.has(key)) {
+          diagnostics.push({
+            severity: "error",
+            location: { stepId: step.id, field: "params.toolInput" },
+            message: `Step '${step.id}' is missing required input key '${key}' for tool '${toolName}'`,
+            code: "MISSING_TOOL_INPUT_KEY"
+          });
+        }
+      }
+    }
+    if (step.type === "agent-loop") {
+      for (const [i, toolName] of step.params.tools.entries()) {
+        if (!tools[toolName]) {
+          diagnostics.push({
+            severity: "error",
+            location: {
+              stepId: step.id,
+              field: `params.tools[${i}]`
+            },
+            message: `Step '${step.id}' references unknown tool '${toolName}'`,
+            code: "UNKNOWN_TOOL"
+          });
+        }
+      }
+    }
+  }
+  return diagnostics;
+}
+
+// src/compiler/index.ts
+async function compileWorkflow(workflow, options) {
+  const diagnostics = [];
+  const graphResult = buildGraph(workflow);
+  diagnostics.push(...graphResult.diagnostics);
+  const refDiagnostics = validateReferences(workflow);
+  for (const d of refDiagnostics) {
+    if (d.code === "MISSING_INITIAL_STEP" && diagnostics.some((e) => e.code === "MISSING_INITIAL_STEP")) {
+      continue;
+    }
+    diagnostics.push(d);
+  }
+  diagnostics.push(...validateLimits(workflow, options?.limits));
+  let constrainedToolSchemas = null;
+  let toolSchemas = null;
+  if (options?.tools) {
+    toolSchemas = await extractToolSchemas(options.tools);
+    diagnostics.push(...validateTools(workflow, toolSchemas));
+    constrainedToolSchemas = generateConstrainedToolSchemas(workflow, toolSchemas);
+  }
+  if (graphResult.graph) {
+    diagnostics.push(...validateControlFlow(workflow, graphResult.graph, toolSchemas));
+    diagnostics.push(...validateJmespath(workflow, graphResult.graph));
+    if (toolSchemas) {
+      diagnostics.push(...validateForeachTarget(workflow, graphResult.graph, toolSchemas));
+    }
+  }
+  const hasErrors = diagnostics.some((d) => d.severity === "error");
+  let optimizedWorkflow = null;
+  if (graphResult.graph && !hasErrors) {
+    const bpResult = applyBestPractices(workflow, graphResult.graph);
+    optimizedWorkflow = bpResult.workflow;
+    diagnostics.push(...bpResult.diagnostics);
+  }
+  return {
+    diagnostics,
+    graph: graphResult.graph,
+    workflow: optimizedWorkflow,
+    constrainedToolSchemas
+  };
+}
+async function extractToolSchemas(tools) {
+  const schemas = {};
+  for (const [name, toolDef] of Object.entries(tools)) {
+    const jsonSchema = await asSchema(toolDef.inputSchema).jsonSchema;
+    schemas[name] = {
+      inputSchema: jsonSchema
+    };
+    if (toolDef.outputSchema) {
+      schemas[name].outputSchema = await asSchema(toolDef.outputSchema).jsonSchema;
+    }
+  }
+  return schemas;
+}
+// src/executor/errors.ts
+class StepExecutionError extends Error {
+  stepId;
+  code;
+  category;
+  cause;
+  name = "StepExecutionError";
+  constructor(stepId, code, category, message, cause) {
+    super(message);
+    this.stepId = stepId;
+    this.code = code;
+    this.category = category;
+    this.cause = cause;
+  }
+}
+
+class ConfigurationError extends StepExecutionError {
+  constructor(stepId, code, message) {
+    super(stepId, code, "configuration", message);
+  }
+}
+
+class ValidationError extends StepExecutionError {
+  input;
+  constructor(stepId, code, message, input, cause) {
+    super(stepId, code, "validation", message, cause);
+    this.input = input;
+  }
+}
+
+class ExternalServiceError extends StepExecutionError {
+  statusCode;
+  isRetryable;
+  constructor(stepId, code, message, cause, statusCode, isRetryable = true) {
+    super(stepId, code, "external-service", message, cause);
+    this.statusCode = statusCode;
+    this.isRetryable = isRetryable;
+  }
+}
+
+class ExpressionError extends StepExecutionError {
+  expression;
+  constructor(stepId, code, message, expression, cause) {
+    super(stepId, code, "expression", message, cause);
+    this.expression = expression;
+  }
+}
+
+class OutputQualityError extends StepExecutionError {
+  rawOutput;
+  constructor(stepId, code, message, rawOutput, cause) {
+    super(stepId, code, "output-quality", message, cause);
+    this.rawOutput = rawOutput;
+  }
+}
+
+class ExtractionError extends StepExecutionError {
+  reason;
+  constructor(stepId, message, reason) {
+    super(stepId, "EXTRACTION_GAVE_UP", "output-quality", message);
+    this.reason = reason;
+  }
+}
+
+// src/executor/context.ts
+function createDefaultDurableContext() {
+  return {
+    step: (_name, fn) => fn(),
+    sleep: (_name, ms) => new Promise((r) => setTimeout(r, ms)),
+    waitForCondition: async (_name, checkFn, opts) => {
+      let delay = opts.intervalMs;
+      const deadline = opts.timeoutMs ? Date.now() + opts.timeoutMs : undefined;
+      for (let attempt = 0;attempt < opts.maxAttempts; attempt++) {
+        const result = await checkFn();
+        if (result)
+          return result;
+        if (deadline && Date.now() + delay > deadline) {
+          throw new ExternalServiceError(_name, "WAIT_CONDITION_TIMEOUT", `wait-for-condition '${_name}' timed out after ${opts.timeoutMs}ms`, undefined, undefined, false);
+        }
+        await new Promise((r) => setTimeout(r, delay));
+        delay *= opts.backoffMultiplier;
+      }
+      throw new ExternalServiceError(_name, "WAIT_CONDITION_MAX_ATTEMPTS", `wait-for-condition '${_name}' exceeded ${opts.maxAttempts} attempts`, undefined, undefined, false);
+    }
+  };
+}
+
+// src/executor/state.ts
+import { type } from "arktype";
+var stepStatusSchema = type("'pending' | 'running' | 'completed' | 'failed' | 'skipped'");
+var runStatusSchema = type("'pending' | 'running' | 'completed' | 'failed'");
+var errorSnapshotSchema = type({
+  code: "string",
+  category: "string",
+  message: "string",
+  "stepId?": "string",
+  "statusCode?": "number",
+  "isRetryable?": "boolean"
+});
+var retryRecordSchema = type({
+  attempt: "number",
+  startedAt: "string",
+  failedAt: "string",
+  errorCode: "string",
+  errorMessage: "string"
+});
+var executionPathSegmentSchema = type({
+  type: "'for-each'",
+  stepId: "string",
+  iterationIndex: "number",
+  itemValue: "unknown"
+}).or({
+  type: "'switch-case'",
+  stepId: "string",
+  matchedCaseIndex: "number",
+  matchedValue: "unknown"
+}).or({
+  type: "'wait-for-condition'",
+  stepId: "string",
+  pollAttempt: "number"
+});
+var traceEntrySchema = type({
+  type: "'log'",
+  message: "string",
+  "data?": "unknown"
+}).or({
+  type: "'agent-step'",
+  step: "unknown"
+});
+var stepExecutionRecordSchema = type({
+  stepId: "string",
+  status: stepStatusSchema,
+  "startedAt?": "string",
+  "completedAt?": "string",
+  "durationMs?": "number",
+  "output?": "unknown",
+  "error?": errorSnapshotSchema,
+  "resolvedInputs?": "unknown",
+  "trace?": [traceEntrySchema, "[]"],
+  retries: [retryRecordSchema, "[]"],
+  path: [executionPathSegmentSchema, "[]"]
+});
+var executionStateSchema = type({
+  runId: "string",
+  status: runStatusSchema,
+  startedAt: "string",
+  "completedAt?": "string",
+  "durationMs?": "number",
+  stepRecords: [stepExecutionRecordSchema, "[]"],
+  "output?": "unknown",
+  "error?": errorSnapshotSchema
+});
+var executionDeltaSchema = type({
+  type: "'run-started'",
+  runId: "string",
+  startedAt: "string"
+}).or({
+  type: "'step-started'",
+  stepId: "string",
+  path: [executionPathSegmentSchema, "[]"],
+  startedAt: "string"
+}).or({
+  type: "'step-completed'",
+  stepId: "string",
+  path: [executionPathSegmentSchema, "[]"],
+  completedAt: "string",
+  durationMs: "number",
+  output: "unknown",
+  "resolvedInputs?": "unknown",
+  "trace?": [traceEntrySchema, "[]"]
+}).or({
+  type: "'step-failed'",
+  stepId: "string",
+  path: [executionPathSegmentSchema, "[]"],
+  failedAt: "string",
+  durationMs: "number",
+  error: errorSnapshotSchema,
+  "resolvedInputs?": "unknown"
+}).or({
+  type: "'step-retry'",
+  stepId: "string",
+  path: [executionPathSegmentSchema, "[]"],
+  retry: retryRecordSchema
+}).or({
+  type: "'run-completed'",
+  runId: "string",
+  completedAt: "string",
+  durationMs: "number",
+  "output?": "unknown"
+}).or({
+  type: "'run-failed'",
+  runId: "string",
+  failedAt: "string",
+  durationMs: "number",
+  error: errorSnapshotSchema
+});
+function snapshotError(err) {
+  const snapshot = {
+    code: err.code,
+    category: err.category,
+    message: err.message
+  };
+  if (err.stepId)
+    snapshot.stepId = err.stepId;
+  if ("statusCode" in err && typeof err.statusCode === "number") {
+    snapshot.statusCode = err.statusCode;
+  }
+  if ("isRetryable" in err && typeof err.isRetryable === "boolean") {
+    snapshot.isRetryable = err.isRetryable;
+  }
+  return snapshot;
+}
+function segmentsEqual(sa, sb) {
+  if (sa.type !== sb.type || sa.stepId !== sb.stepId)
+    return false;
+  if (sa.type === "for-each" && sb.type === "for-each") {
+    return sa.iterationIndex === sb.iterationIndex;
+  }
+  if (sa.type === "switch-case" && sb.type === "switch-case") {
+    return sa.matchedCaseIndex === sb.matchedCaseIndex;
+  }
+  if (sa.type === "wait-for-condition" && sb.type === "wait-for-condition") {
+    return sa.pollAttempt === sb.pollAttempt;
+  }
+  return true;
+}
+function pathsEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0;i < a.length; i++) {
+    const sa = a[i];
+    const sb = b[i];
+    if (!segmentsEqual(sa, sb))
+      return false;
+  }
+  return true;
+}
+function findRecordIndex(records, stepId, path) {
+  for (let i = records.length - 1;i >= 0; i--) {
+    const record = records[i];
+    if (record.stepId === stepId && pathsEqual(record.path, path)) {
+      return i;
+    }
+  }
+  return -1;
+}
+function applyDelta(state, delta) {
+  switch (delta.type) {
+    case "run-started":
+      return { ...state, status: "running", startedAt: delta.startedAt };
+    case "step-started": {
+      const record = {
+        stepId: delta.stepId,
+        status: "running",
+        startedAt: delta.startedAt,
+        retries: [],
+        path: delta.path
+      };
+      return {
+        ...state,
+        stepRecords: [...state.stepRecords, record]
+      };
+    }
+    case "step-completed": {
+      const records = [...state.stepRecords];
+      const idx = findRecordIndex(records, delta.stepId, delta.path);
+      if (idx >= 0) {
+        const existing = records[idx];
+        const updated = {
+          ...existing,
+          status: "completed",
+          completedAt: delta.completedAt,
+          durationMs: delta.durationMs,
+          output: delta.output
+        };
+        if (delta.resolvedInputs !== undefined) {
+          updated.resolvedInputs = delta.resolvedInputs;
+        }
+        if (delta.trace !== undefined) {
+          updated.trace = delta.trace;
+        }
+        records[idx] = updated;
+      }
+      return { ...state, stepRecords: records };
+    }
+    case "step-failed": {
+      const records = [...state.stepRecords];
+      const idx = findRecordIndex(records, delta.stepId, delta.path);
+      if (idx >= 0) {
+        const existing = records[idx];
+        const updated = {
+          ...existing,
+          status: "failed",
+          completedAt: delta.failedAt,
+          durationMs: delta.durationMs,
+          error: delta.error
+        };
+        if (delta.resolvedInputs !== undefined) {
+          updated.resolvedInputs = delta.resolvedInputs;
+        }
+        records[idx] = updated;
+      }
+      return { ...state, stepRecords: records };
+    }
+    case "step-retry": {
+      const records = [...state.stepRecords];
+      const idx = findRecordIndex(records, delta.stepId, delta.path);
+      if (idx >= 0) {
+        const existing = records[idx];
+        records[idx] = {
+          ...existing,
+          retries: [...existing.retries, delta.retry]
+        };
+      }
+      return { ...state, stepRecords: records };
+    }
+    case "run-completed":
+      return {
+        ...state,
+        status: "completed",
+        completedAt: delta.completedAt,
+        durationMs: delta.durationMs,
+        output: delta.output
+      };
+    case "run-failed":
+      return {
+        ...state,
+        status: "failed",
+        completedAt: delta.failedAt,
+        durationMs: delta.durationMs,
+        error: delta.error
+      };
+  }
+}
+
+// src/executor/executor-types.ts
+var DEFAULT_EXECUTOR_LIMITS = {
+  maxTotalMs: 600000,
+  maxActiveMs: 300000,
+  maxSleepMs: 300000,
+  maxAttempts: Number.POSITIVE_INFINITY,
+  maxBackoffMultiplier: 2,
+  minBackoffMultiplier: 1,
+  maxTimeoutMs: 600000,
+  probeThresholdBytes: 50000,
+  probeResultMaxBytes: 1e4,
+  probeMaxSteps: 10
+};
+
+class ExecutionTimer {
+  startTime = Date.now();
+  activeMs = 0;
+  activeStart = null;
+  limits;
+  constructor(limits) {
+    this.limits = { ...DEFAULT_EXECUTOR_LIMITS, ...limits };
+  }
+  get resolvedLimits() {
+    return this.limits;
+  }
+  beginActive() {
+    this.activeStart = Date.now();
+  }
+  endActive(stepId) {
+    if (this.activeStart !== null) {
+      this.activeMs += Date.now() - this.activeStart;
+      this.activeStart = null;
+    }
+    if (this.activeMs > this.limits.maxActiveMs) {
+      throw new ExternalServiceError(stepId, "EXECUTION_ACTIVE_TIMEOUT", `Active execution time ${this.activeMs}ms exceeded limit of ${this.limits.maxActiveMs}ms`, undefined, undefined, false);
+    }
+  }
+  checkTotal(stepId) {
+    const elapsed = Date.now() - this.startTime;
+    if (elapsed > this.limits.maxTotalMs) {
+      throw new ExternalServiceError(stepId, "EXECUTION_TOTAL_TIMEOUT", `Total execution time ${elapsed}ms exceeded limit of ${this.limits.maxTotalMs}ms`, undefined, undefined, false);
+    }
+  }
+}
+
+class ExecutionStateManager {
+  state;
+  onChange;
+  constructor(onChange) {
+    this.state = {
+      runId: crypto.randomUUID(),
+      status: "pending",
+      startedAt: new Date().toISOString(),
+      stepRecords: []
+    };
+    this.onChange = onChange;
+  }
+  get currentState() {
+    return this.state;
+  }
+  emit(delta) {
+    this.state = applyDelta(this.state, delta);
+    this.onChange?.(this.state, delta);
+  }
+  runStarted() {
+    this.emit({
+      type: "run-started",
+      runId: this.state.runId,
+      startedAt: this.state.startedAt
+    });
+  }
+  stepStarted(stepId, path) {
+    this.emit({
+      type: "step-started",
+      stepId,
+      path,
+      startedAt: new Date().toISOString()
+    });
+  }
+  stepCompleted(stepId, path, output, durationMs, resolvedInputs, trace) {
+    this.emit({
+      type: "step-completed",
+      stepId,
+      path,
+      completedAt: new Date().toISOString(),
+      durationMs,
+      output,
+      resolvedInputs,
+      trace
+    });
+  }
+  stepFailed(stepId, path, error, durationMs, resolvedInputs) {
+    this.emit({
+      type: "step-failed",
+      stepId,
+      path,
+      failedAt: new Date().toISOString(),
+      durationMs,
+      error: snapshotError(error),
+      resolvedInputs
+    });
+  }
+  retryAttempted(stepId, path, retry) {
+    this.emit({
+      type: "step-retry",
+      stepId,
+      path,
+      retry
+    });
+  }
+  runCompleted(output) {
+    const startMs = new Date(this.state.startedAt).getTime();
+    this.emit({
+      type: "run-completed",
+      runId: this.state.runId,
+      completedAt: new Date().toISOString(),
+      durationMs: Date.now() - startMs,
+      output
+    });
+  }
+  runFailed(error) {
+    const startMs = new Date(this.state.startedAt).getTime();
+    this.emit({
+      type: "run-failed",
+      runId: this.state.runId,
+      failedAt: new Date().toISOString(),
+      durationMs: Date.now() - startMs,
+      error: snapshotError(error)
+    });
+  }
+}
+
+// src/executor/steps/agent-loop.ts
+import {
+  generateText,
+  jsonSchema,
+  Output,
+  stepCountIs,
+  ToolLoopAgent
+} from "ai";
+
+// src/executor/helpers.ts
+import { search } from "@jmespath-community/jmespath";
+import {
+  APICallError,
+  JSONParseError,
+  NoContentGeneratedError,
+  RetryError,
+  TypeValidationError,
+  tool
+} from "ai";
+import { type as arktype } from "arktype";
+function evaluateExpression(expr, scope, stepId) {
+  if (expr.type === "literal") {
+    return expr.value;
+  }
+  if (expr.type === "template") {
+    return interpolateTemplate(expr.template, scope, stepId);
+  }
+  try {
+    return search(scope, expr.expression);
+  } catch (e) {
+    throw new ExpressionError(stepId, "JMESPATH_EVALUATION_ERROR", `JMESPath expression '${expr.expression}' failed: ${e instanceof Error ? e.message : String(e)}`, expr.expression, e);
+  }
+}
+function stringifyValue(value) {
+  if (value === null || value === undefined)
+    return "";
+  if (typeof value === "object")
+    return JSON.stringify(value);
+  return String(value);
+}
+function interpolateTemplate(template, scope, stepId) {
+  const { expressions } = extractTemplateExpressions(template);
+  if (expressions.length === 0)
+    return template;
+  let result = "";
+  let lastEnd = 0;
+  for (const expr of expressions) {
+    result += template.slice(lastEnd, expr.start);
+    try {
+      const value = search(scope, expr.expression);
+      result += stringifyValue(value);
+    } catch (e) {
+      throw new ExpressionError(stepId, "TEMPLATE_INTERPOLATION_ERROR", `Template expression '${expr.expression}' failed: ${e instanceof Error ? e.message : String(e)}`, expr.expression, e);
+    }
+    lastEnd = expr.end;
+  }
+  result += template.slice(lastEnd);
+  return result;
+}
+function classifyLlmError(stepId, e) {
+  if (APICallError.isInstance(e)) {
+    const code = e.statusCode === 429 ? "LLM_RATE_LIMITED" : "LLM_API_ERROR";
+    return new ExternalServiceError(stepId, code, e.message, e, e.statusCode, e.isRetryable ?? true);
+  }
+  if (RetryError.isInstance(e)) {
+    return new ExternalServiceError(stepId, "LLM_API_ERROR", e.message, e, undefined, false);
+  }
+  if (NoContentGeneratedError.isInstance(e)) {
+    return new ExternalServiceError(stepId, "LLM_NO_CONTENT", e.message, e, undefined, true);
+  }
+  if (TypeValidationError.isInstance(e)) {
+    return new OutputQualityError(stepId, "LLM_OUTPUT_PARSE_ERROR", `LLM output could not be parsed: ${e.message}`, e.value, e);
+  }
+  if (JSONParseError.isInstance(e)) {
+    return new OutputQualityError(stepId, "LLM_OUTPUT_PARSE_ERROR", `LLM output could not be parsed: ${e.message}`, e.text, e);
+  }
+  return new ExternalServiceError(stepId, "LLM_NETWORK_ERROR", e instanceof Error ? e.message : String(e), e, undefined, true);
+}
+function createProbeDataTool(sourceData, limits) {
+  return tool({
+    description: "Query the available data using a JMESPath expression. Returns the matching subset of the data.",
+    inputSchema: arktype({
+      expression: [
+        "string",
+        "@",
+        "A JMESPath expression to evaluate against the data. Examples: 'users[0]', 'users[*].name', 'metadata.total', 'users[?age > `30`].name'"
+      ]
+    }),
+    execute: async ({ expression }) => {
+      try {
+        const result = search(sourceData, expression);
+        const resultStr = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+        if (new TextEncoder().encode(resultStr).byteLength > limits.probeResultMaxBytes) {
+          const truncated = resultStr.slice(0, limits.probeResultMaxBytes);
+          return `${truncated}
+
+[TRUNCATED - result exceeded ${limits.probeResultMaxBytes} bytes. Use a more specific JMESPath expression to narrow the result.]`;
+        }
+        return resultStr;
+      } catch (e) {
+        return `JMESPath error: ${e instanceof Error ? e.message : String(e)}. Check your expression syntax.`;
+      }
+    }
+  });
+}
+function createGiveUpTool() {
+  let reason;
+  const giveUpTool = tool({
+    description: "Call this if you determine you cannot complete the task or find/extract the requested data.",
+    inputSchema: arktype({
+      reason: [
+        "string",
+        "@",
+        "Explanation of why the task cannot be completed"
+      ]
+    }),
+    execute: async ({ reason: r }) => {
+      reason = r;
+      return { acknowledged: true };
+    }
+  });
+  return {
+    tool: giveUpTool,
+    getReason: () => reason
+  };
+}
+
+// src/executor/steps/agent-loop.ts
+async function executeAgentLoop(step, scope, options, limits) {
+  if (!options.model) {
+    throw new ConfigurationError(step.id, "AGENT_NOT_PROVIDED", "agent-loop steps require a LanguageModel to be provided");
+  }
+  const interpolatedInstructions = interpolateTemplate(step.params.instructions, scope, step.id);
+  const outputSchema = jsonSchema(step.params.outputFormat);
+  if (options.agent) {
+    return executeWithAgent(step, interpolatedInstructions, options.agent, options.model, outputSchema, step.params.outputFormat);
+  }
+  return executeWithModel(step, interpolatedInstructions, scope, options, options.model, limits, outputSchema);
+}
+async function executeWithAgent(step, interpolatedInstructions, agent, model, outputSchema, rawOutputFormat) {
+  const schemaStr = JSON.stringify(rawOutputFormat, null, 2);
+  const prompt = `${interpolatedInstructions}
+
+When you have completed the task, respond with your final answer. Your response should contain the following structured information matching this JSON Schema:
+\`\`\`json
+${schemaStr}
+\`\`\`
+
+Include all the required fields in your response.`;
+  try {
+    const result = await agent.generate({ prompt });
+    const giveUp = createGiveUpTool();
+    const coerced = await generateText({
+      model,
+      output: Output.object({ schema: outputSchema }),
+      tools: { "give-up": giveUp.tool },
+      prompt: `Extract the structured data from the following text. Return only the data matching the schema. If the text does not contain enough information to populate the required fields, call the give-up tool with an explanation.
+
+Text:
+${result.text}`
+    });
+    if (giveUp.getReason() !== undefined) {
+      throw new ExtractionError(step.id, `Could not coerce agent output into expected schema: ${giveUp.getReason()}`, giveUp.getReason());
+    }
+    const trace = [
+      ...result.steps.map((s) => ({ type: "agent-step", step: s })),
+      ...coerced.steps.map((s) => ({ type: "agent-step", step: s }))
+    ];
+    return { output: coerced.output, trace };
+  } catch (e) {
+    if (e instanceof StepExecutionError)
+      throw e;
+    throw classifyLlmError(step.id, e);
+  }
+}
+async function executeWithModel(step, interpolatedInstructions, scope, options, model, limits, outputSchema) {
+  const subsetTools = {};
+  for (const toolName of step.params.tools) {
+    const toolDef = options.tools[toolName];
+    if (!toolDef) {
+      throw new ConfigurationError(step.id, "TOOL_NOT_FOUND", `agent-loop step references tool '${toolName}' which is not in the provided tool set`);
+    }
+    if (!toolDef.execute) {
+      throw new ConfigurationError(step.id, "TOOL_MISSING_EXECUTE", `agent-loop step references tool '${toolName}' which has no execute function`);
+    }
+    subsetTools[toolName] = toolDef;
+  }
+  const probeDataTool = createProbeDataTool(scope, limits);
+  const giveUp = createGiveUpTool();
+  subsetTools["probe-data"] = probeDataTool;
+  subsetTools["give-up"] = giveUp.tool;
+  const maxSteps = step.params.maxSteps ? evaluateExpression(step.params.maxSteps, scope, step.id) : 10;
+  if (typeof maxSteps !== "number" || maxSteps < 1) {
+    throw new ValidationError(step.id, "TOOL_INPUT_VALIDATION_FAILED", `agent-loop maxSteps must be a positive number, got ${typeof maxSteps === "number" ? maxSteps : typeof maxSteps}`, maxSteps);
+  }
+  const agent = new ToolLoopAgent({
+    model,
+    tools: subsetTools,
+    output: Output.object({ schema: outputSchema }),
+    stopWhen: [
+      () => giveUp?.getReason() !== undefined,
+      stepCountIs(Math.floor(maxSteps))
+    ]
+  });
+  try {
+    const result = await agent.generate({ prompt: interpolatedInstructions });
+    if (giveUp.getReason() !== undefined) {
+      throw new ExtractionError(step.id, `Agent gave up: ${giveUp.getReason()}`, giveUp.getReason());
+    }
+    const trace = result.steps.map((s) => ({
+      type: "agent-step",
+      step: s
+    }));
+    return { output: result.output, trace };
+  } catch (e) {
+    if (e instanceof StepExecutionError)
+      throw e;
+    throw classifyLlmError(step.id, e);
+  }
+}
+function resolveAgentLoopInputs(step, scope) {
+  try {
+    return {
+      instructions: interpolateTemplate(step.params.instructions, scope, step.id)
+    };
+  } catch {
+    return { instructions: step.params.instructions };
+  }
+}
+
+// src/executor/steps/end.ts
+function executeEnd(step, scope) {
+  if (step.params?.output) {
+    return evaluateExpression(step.params.output, scope, step.id);
+  }
+  return;
+}
+
+// src/executor/steps/extract-data.ts
+import { safeValidateTypes } from "@ai-sdk/provider-utils";
+import { search as search2 } from "@jmespath-community/jmespath";
+import {
+  jsonSchema as jsonSchema2,
+  Output as Output2,
+  stepCountIs as stepCountIs2,
+  ToolLoopAgent as ToolLoopAgent2,
+  tool as tool2
+} from "ai";
+
+// src/executor/schema-inference.ts
+function deepEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function normalizeSchemaShape(schema) {
+  if (schema === null || schema === undefined)
+    return schema;
+  if (typeof schema === "string")
+    return schema;
+  if (Array.isArray(schema)) {
+    if (schema.length === 2 && typeof schema[1] === "number") {
+      return [normalizeSchemaShape(schema[0]), 0];
+    }
+    return schema.map(normalizeSchemaShape);
+  }
+  if (typeof schema === "object") {
+    const normalized = {};
+    for (const [key, val] of Object.entries(schema)) {
+      normalized[key] = normalizeSchemaShape(val);
+    }
+    return normalized;
+  }
+  return schema;
+}
+function mostCommon(arr) {
+  if (arr.length === 0)
+    return null;
+  const counts = new Map;
+  arr.forEach((item) => {
+    let found = false;
+    for (const [_idx, entry] of counts.entries()) {
+      if (deepEqual(item, entry.element)) {
+        entry.count++;
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      counts.set(counts.size, { element: item, count: 1 });
+    }
+  });
+  let max = { element: arr[0], count: 0 };
+  for (const entry of counts.values()) {
+    if (entry.count > max.count)
+      max = entry;
+  }
+  return max.element;
+}
+function inferSchema(value, types = [], maxKeys = 20) {
+  let schema;
+  if (value === null) {
+    schema = "null";
+  } else if (value === undefined) {
+    schema = "undefined";
+  } else if (typeof value === "object") {
+    if (Array.isArray(value)) {
+      const elementSchemas = value.map((element) => inferSchema(element, types, maxKeys));
+      const mostCommonElementSchema = mostCommon(elementSchemas);
+      const percentUniformSchemas = elementSchemas.filter((schema2) => deepEqual(schema2, mostCommonElementSchema)).length / elementSchemas.length;
+      const allElementsHaveSameSchema = percentUniformSchemas >= 0.5;
+      if (allElementsHaveSameSchema) {
+        schema = [mostCommonElementSchema, value.length];
+      } else {
+        schema = elementSchemas;
+      }
+    } else {
+      const keys = Object.keys(value);
+      const totalKeys = keys.length;
+      if (totalKeys >= 3) {
+        const sampleKeys = keys.slice(0, maxKeys);
+        const valueSchemas = sampleKeys.map((key) => inferSchema(value[key], [], maxKeys));
+        const normalizedSchemas = valueSchemas.map(normalizeSchemaShape);
+        const mostCommonNormalized = mostCommon(normalizedSchemas);
+        if (mostCommonNormalized !== null && typeof mostCommonNormalized === "object" && mostCommonNormalized !== null) {
+          const uniformCount = normalizedSchemas.filter((s) => deepEqual(s, mostCommonNormalized)).length;
+          const percentUniform = uniformCount / sampleKeys.length;
+          if (uniformCount >= 3 && percentUniform >= 0.75) {
+            const representativeSchema = valueSchemas.find((s) => deepEqual(normalizeSchemaShape(s), mostCommonNormalized));
+            schema = {
+              __dict: [representativeSchema, totalKeys]
+            };
+            types.push(schema);
+            return schema;
+          }
+        }
+      }
+      const _schema = {};
+      const keysToInclude = keys.slice(0, maxKeys);
+      for (const key of keysToInclude) {
+        _schema[key] = inferSchema(value[key], types, maxKeys);
+      }
+      if (totalKeys > maxKeys) {
+        _schema[`...${totalKeys - maxKeys} more keys`] = "truncated";
+      }
+      schema = _schema;
+    }
+  } else if (typeof value === "string") {
+    schema = "string";
+  } else if (typeof value === "number") {
+    schema = "number";
+  } else if (typeof value === "boolean") {
+    schema = "boolean";
+  } else {
+    schema = "unknown";
+  }
+  types.push(schema);
+  return schema;
+}
+function schemaToString(schema, indent) {
+  const indentStr = typeof indent === "number" ? " ".repeat(indent) : indent;
+  const pretty = indentStr !== undefined;
+  function stringify(value, depth = 0) {
+    if (value === null)
+      return "null";
+    if (value === undefined)
+      return "undefined";
+    if (typeof value === "string")
+      return value;
+    if (Array.isArray(value)) {
+      if (value.length === 2 && typeof value[1] === "number") {
+        return `${stringify(value[0], depth)}[${value[1]}]`;
+      }
+      if (!pretty || !indentStr) {
+        return `[${value.map((v) => stringify(v, depth)).join(", ")}]`;
+      }
+      const currentIndent = indentStr.repeat(depth);
+      const nextIndent = indentStr.repeat(depth + 1);
+      const items = value.map((v) => `${nextIndent}${stringify(v, depth + 1)}`).join(`,
+`);
+      return `[
+${items}
+${currentIndent}]`;
+    }
+    if (typeof value === "object") {
+      const entries = Object.entries(value);
+      const first = entries[0];
+      if (entries.length === 1 && first !== undefined && first[0] === "__dict" && Array.isArray(first[1]) && first[1].length === 2 && typeof first[1][1] === "number") {
+        const [valueSchema, count] = first[1];
+        if (!pretty || !indentStr) {
+          return `{ [key]: ${stringify(valueSchema, depth)} }[${count}]`;
+        }
+        const currentIndent2 = indentStr.repeat(depth);
+        const nextIndent2 = indentStr.repeat(depth + 1);
+        return `{
+${nextIndent2}[key]: ${stringify(valueSchema, depth + 1)}
+${currentIndent2}}[${count}]`;
+      }
+      if (!pretty || !indentStr) {
+        const formatted2 = entries.map(([key, val]) => `${key}: ${stringify(val, depth)}`).join(", ");
+        return `{ ${formatted2} }`;
+      }
+      const currentIndent = indentStr.repeat(depth);
+      const nextIndent = indentStr.repeat(depth + 1);
+      const formatted = entries.map(([key, val]) => `${nextIndent}${key}: ${stringify(val, depth + 1)}`).join(`,
+`);
+      return `{
+${formatted}
+${currentIndent}}`;
+    }
+    return JSON.stringify(value);
+  }
+  return stringify(schema);
+}
+function summarizeObjectStructure(value, indent) {
+  const schema = inferSchema(value);
+  return schemaToString(schema, indent);
+}
+
+// src/executor/steps/extract-data.ts
+async function executeExtractData(step, scope, options, limits) {
+  if (!options.model) {
+    throw new ConfigurationError(step.id, "AGENT_NOT_PROVIDED", "extract-data steps require a LanguageModel to be provided");
+  }
+  const { model } = options;
+  const sourceData = evaluateExpression(step.params.sourceData, scope, step.id);
+  const sourceStr = typeof sourceData === "string" ? sourceData : JSON.stringify(sourceData, null, 2);
+  const byteLength = new TextEncoder().encode(sourceStr).byteLength;
+  let useProbeMode = byteLength > limits.probeThresholdBytes;
+  if (useProbeMode && typeof sourceData === "string") {
+    try {
+      JSON.parse(sourceData);
+    } catch {
+      useProbeMode = false;
+    }
+  }
+  if (useProbeMode) {
+    const structuredData = typeof sourceData === "string" ? JSON.parse(sourceData) : sourceData;
+    return executeExtractDataProbe(step, structuredData, model, limits);
+  }
+  const agent = new ToolLoopAgent2({
+    model,
+    output: Output2.object({
+      schema: jsonSchema2(step.params.outputFormat)
+    }),
+    stopWhen: stepCountIs2(1)
+  });
+  const prompt = `Extract the following structured data from the provided source data.
+
+Source data:
+${sourceStr}`;
+  try {
+    const result = await agent.generate({ prompt });
+    const trace = result.steps.map((s) => ({
+      type: "agent-step",
+      step: s
+    }));
+    return { output: result.output, trace };
+  } catch (e) {
+    if (e instanceof StepExecutionError)
+      throw e;
+    throw classifyLlmError(step.id, e);
+  }
+}
+async function executeExtractDataProbe(step, sourceData, model, limits) {
+  const structureSummary = summarizeObjectStructure(sourceData, 2);
+  let submittedResult;
+  const outputSchema = jsonSchema2(step.params.outputFormat);
+  const probeDataTool = createProbeDataTool(sourceData, limits);
+  const giveUp = createGiveUpTool();
+  const submitResultTool = tool2({
+    description: "Submit the extracted data. Provide either `data` (the object directly) or `expression` (a JMESPath expression that evaluates to it). The result is validated against the target schema.",
+    inputSchema: jsonSchema2({
+      type: "object",
+      properties: {
+        data: { description: "The extracted data object directly" },
+        expression: {
+          type: "string",
+          description: "A JMESPath expression that evaluates to the extracted data"
+        }
+      }
+    }),
+    execute: async (input) => {
+      let result2;
+      if (input.expression !== undefined) {
+        try {
+          result2 = search2(sourceData, input.expression);
+        } catch (e) {
+          throw new Error(`JMESPath error: ${e instanceof Error ? e.message : String(e)}. Fix the expression and try again.`);
+        }
+      } else if (input.data !== undefined) {
+        result2 = input.data;
+      } else {
+        throw new Error("Provide either `data` or `expression` to submit a result.");
+      }
+      const validation = await safeValidateTypes({
+        value: result2,
+        schema: outputSchema
+      });
+      if (!validation.success) {
+        throw new Error(`Result does not match the target output schema: ${validation.error.message}. Fix the data or expression and try again.`);
+      }
+      submittedResult = validation.value;
+      return { success: true };
+    }
+  });
+  const agent = new ToolLoopAgent2({
+    model,
+    tools: {
+      "probe-data": probeDataTool,
+      "submit-result": submitResultTool,
+      "give-up": giveUp.tool
+    },
+    stopWhen: [
+      () => submittedResult !== undefined || giveUp.getReason() !== undefined,
+      stepCountIs2(limits.probeMaxSteps)
+    ]
+  });
+  const schemaStr = JSON.stringify(step.params.outputFormat, null, 2);
+  const prompt = `You need to extract structured data from a large dataset. The data is too large to include directly, so you have three tools:
+
+- probe-data: Query the data with a JMESPath expression to explore its contents.
+- submit-result: Submit the final extraction. Pass either \`data\` (the object directly) or \`expression\` (a JMESPath expression that evaluates to it). The result is validated against the target schema — if invalid, you'll get an error and can retry.
+- give-up: Call this if you determine the requested data cannot be found or extracted.
+
+## Data Structure Summary
+\`\`\`
+${structureSummary}
+\`\`\`
+
+## Target Output Schema
+\`\`\`json
+${schemaStr}
+\`\`\`
+
+## Instructions
+1. Use probe-data with JMESPath expressions to explore and extract values you need.
+2. When you have all the data, call submit-result with either the data directly or a JMESPath expression that produces it.
+3. If the data you need is not present or cannot be extracted, call give-up with a reason.`;
+  let result;
+  try {
+    result = await agent.generate({ prompt });
+  } catch (e) {
+    if (e instanceof StepExecutionError)
+      throw e;
+    throw classifyLlmError(step.id, e);
+  }
+  const trace = result.steps.map((s) => ({
+    type: "agent-step",
+    step: s
+  }));
+  if (submittedResult !== undefined) {
+    return { output: submittedResult, trace };
+  }
+  if (giveUp.getReason() !== undefined) {
+    throw new ExtractionError(step.id, `LLM was unable to extract the requested data: ${giveUp.getReason()}`, giveUp.getReason());
+  }
+  throw new OutputQualityError(step.id, "LLM_OUTPUT_PARSE_ERROR", "extract-data probe mode exhausted all steps without submitting a result", undefined);
+}
+function resolveExtractDataInputs(step, scope) {
+  try {
+    return {
+      sourceData: evaluateExpression(step.params.sourceData, scope, step.id)
+    };
+  } catch {
+    return;
+  }
+}
+
+// src/executor/steps/for-each.ts
+async function executeForEach(step, scope, stepIndex, stepOutputs, loopVars, options, context, stateManager, execPath, executeChain) {
+  const target = evaluateExpression(step.params.target, scope, step.id);
+  if (!Array.isArray(target)) {
+    throw new ValidationError(step.id, "FOREACH_TARGET_NOT_ARRAY", `for-each target must be an array, got ${typeof target}`, target);
+  }
+  const results = [];
+  for (let i = 0;i < target.length; i++) {
+    const item = target[i];
+    const iterationPath = [
+      ...execPath,
+      {
+        type: "for-each",
+        stepId: step.id,
+        iterationIndex: i,
+        itemValue: item
+      }
+    ];
+    const innerLoopVars = { ...loopVars, [step.params.itemName]: item };
+    const lastOutput = await executeChain(step.params.loopBodyStepId, stepIndex, stepOutputs, innerLoopVars, options, context, undefined, stateManager, iterationPath);
+    results.push(lastOutput);
+  }
+  return results;
+}
+function resolveForEachInputs(step, scope) {
+  try {
+    return {
+      target: evaluateExpression(step.params.target, scope, step.id)
+    };
+  } catch {
+    return;
+  }
+}
+
+// src/executor/steps/llm-prompt.ts
+import { jsonSchema as jsonSchema3, Output as Output3, stepCountIs as stepCountIs3, ToolLoopAgent as ToolLoopAgent3 } from "ai";
+async function executeLlmPrompt(step, scope, options) {
+  if (!options.model) {
+    throw new ConfigurationError(step.id, "AGENT_NOT_PROVIDED", "llm-prompt steps require a LanguageModel to be provided");
+  }
+  const prompt = interpolateTemplate(step.params.prompt, scope, step.id);
+  const agent = new ToolLoopAgent3({
+    model: options.model,
+    output: Output3.object({
+      schema: jsonSchema3(step.params.outputFormat)
+    }),
+    stopWhen: stepCountIs3(1)
+  });
+  try {
+    const result = await agent.generate({ prompt });
+    const trace = result.steps.map((s) => ({
+      type: "agent-step",
+      step: s
+    }));
+    return { output: result.output, trace };
+  } catch (e) {
+    if (e instanceof StepExecutionError)
+      throw e;
+    throw classifyLlmError(step.id, e);
+  }
+}
+function resolveLlmPromptInputs(step, scope) {
+  try {
+    return {
+      prompt: interpolateTemplate(step.params.prompt, scope, step.id)
+    };
+  } catch {
+    return { prompt: step.params.prompt };
+  }
+}
+
+// src/executor/steps/sleep.ts
+async function executeSleep(step, scope, context, timer) {
+  const durationMs = evaluateExpression(step.params.durationMs, scope, step.id);
+  if (typeof durationMs !== "number" || durationMs < 0) {
+    throw new ValidationError(step.id, "SLEEP_INVALID_DURATION", `sleep durationMs must be a non-negative number, got ${typeof durationMs === "number" ? durationMs : typeof durationMs}`, durationMs);
+  }
+  const clamped = Math.min(durationMs, timer.resolvedLimits.maxSleepMs);
+  await context.sleep(step.id, clamped);
+}
+
+// src/executor/steps/start.ts
+function executeStart() {
+  return;
+}
+
+// src/executor/steps/switch-case.ts
+async function executeSwitchCase(step, scope, stepIndex, stepOutputs, loopVars, options, context, stateManager, execPath, executeChain) {
+  const switchValue = evaluateExpression(step.params.switchOn, scope, step.id);
+  let matchedBranchId;
+  let defaultBranchId;
+  let matchedCaseIndex = -1;
+  for (let i = 0;i < step.params.cases.length; i++) {
+    const c = step.params.cases[i];
+    if (c.value.type === "default") {
+      defaultBranchId = c.branchBodyStepId;
+      if (matchedCaseIndex === -1)
+        matchedCaseIndex = i;
+    } else {
+      const caseValue = evaluateExpression(c.value, scope, step.id);
+      if (caseValue === switchValue) {
+        matchedBranchId = c.branchBodyStepId;
+        matchedCaseIndex = i;
+        break;
+      }
+    }
+  }
+  const selectedBranchId = matchedBranchId ?? defaultBranchId;
+  if (!selectedBranchId) {
+    return;
+  }
+  const branchPath = [
+    ...execPath,
+    {
+      type: "switch-case",
+      stepId: step.id,
+      matchedCaseIndex,
+      matchedValue: switchValue
+    }
+  ];
+  return await executeChain(selectedBranchId, stepIndex, stepOutputs, loopVars, options, context, undefined, stateManager, branchPath);
+}
+function resolveSwitchCaseInputs(step, scope) {
+  try {
+    return {
+      switchOn: evaluateExpression(step.params.switchOn, scope, step.id)
+    };
+  } catch {
+    return;
+  }
+}
+
+// src/executor/steps/tool-call.ts
+import { safeValidateTypes as safeValidateTypes2 } from "@ai-sdk/provider-utils";
+async function executeToolCall(step, scope, tools) {
+  const toolDef = tools[step.params.toolName];
+  if (!toolDef?.execute) {
+    throw new ConfigurationError(step.id, "TOOL_NOT_FOUND", `Tool '${step.params.toolName}' not found or has no execute function`);
+  }
+  const resolvedInput = {};
+  for (const [key, expr] of Object.entries(step.params.toolInput)) {
+    resolvedInput[key] = evaluateExpression(expr, scope, step.id);
+  }
+  if (toolDef.inputSchema) {
+    const validation = await safeValidateTypes2({
+      value: resolvedInput,
+      schema: toolDef.inputSchema
+    });
+    if (!validation.success) {
+      throw new ValidationError(step.id, "TOOL_INPUT_VALIDATION_FAILED", `Tool '${step.params.toolName}' input validation failed: ${validation.error.message}`, resolvedInput, validation.error);
+    }
+  }
+  try {
+    return await toolDef.execute(resolvedInput, {
+      toolCallId: step.id,
+      messages: []
+    });
+  } catch (e) {
+    throw new ExternalServiceError(step.id, "TOOL_EXECUTION_FAILED", e instanceof Error ? e.message : String(e), e);
+  }
+}
+function resolveToolCallInputs(step, scope) {
+  const resolved = {};
+  for (const [key, expr] of Object.entries(step.params.toolInput)) {
+    try {
+      resolved[key] = evaluateExpression(expr, scope, step.id);
+    } catch {
+      resolved[key] = `<error resolving ${key}>`;
+    }
+  }
+  return resolved;
+}
+
+// src/executor/steps/wait-for-condition.ts
+async function executeWaitForCondition(step, scope, stepIndex, stepOutputs, loopVars, options, context, timer, stateManager, execPath, executeChain) {
+  const limits = timer.resolvedLimits;
+  const maxAttempts = Math.min(step.params.maxAttempts ? evaluateExpression(step.params.maxAttempts, scope, step.id) : 10, limits.maxAttempts);
+  const intervalMs = Math.min(step.params.intervalMs ? evaluateExpression(step.params.intervalMs, scope, step.id) : 1000, limits.maxSleepMs);
+  const rawBackoff = step.params.backoffMultiplier ? evaluateExpression(step.params.backoffMultiplier, scope, step.id) : 1;
+  const backoffMultiplier = Math.max(limits.minBackoffMultiplier, Math.min(rawBackoff, limits.maxBackoffMultiplier));
+  const timeoutMs = step.params.timeoutMs ? Math.min(evaluateExpression(step.params.timeoutMs, scope, step.id), limits.maxTimeoutMs) : undefined;
+  let pollAttempt = 0;
+  return context.waitForCondition(step.id, async () => {
+    const pollPath = [
+      ...execPath,
+      {
+        type: "wait-for-condition",
+        stepId: step.id,
+        pollAttempt: pollAttempt++
+      }
+    ];
+    timer.beginActive();
+    try {
+      await executeChain(step.params.conditionStepId, stepIndex, stepOutputs, loopVars, options, context, undefined, stateManager, pollPath);
+      const updatedScope = { ...stepOutputs, ...loopVars };
+      return evaluateExpression(step.params.condition, updatedScope, step.id);
+    } finally {
+      timer.endActive(step.id);
+    }
+  }, { maxAttempts, intervalMs, backoffMultiplier, timeoutMs });
+}
+
+// src/executor/index.ts
+function validateWorkflowInputs(inputSchema, inputs) {
+  if (!inputSchema || typeof inputSchema !== "object")
+    return;
+  const required = inputSchema.required;
+  if (Array.isArray(required)) {
+    const missing = required.filter((key) => typeof key === "string" && !(key in inputs));
+    if (missing.length > 0) {
+      throw new ValidationError("input", "TOOL_INPUT_VALIDATION_FAILED", `Workflow input validation failed: missing required input(s): ${missing.join(", ")}`, inputs);
+    }
+  }
+  const properties = inputSchema.properties;
+  if (properties && typeof properties === "object") {
+    for (const [key, value] of Object.entries(inputs)) {
+      const propSchema = properties[key];
+      if (propSchema && typeof propSchema === "object" && "type" in propSchema) {
+        const expectedType = propSchema.type;
+        const actualType = typeof value;
+        if (expectedType === "integer" || expectedType === "number") {
+          if (actualType !== "number") {
+            throw new ValidationError("input", "TOOL_INPUT_VALIDATION_FAILED", `Workflow input validation failed: input '${key}' expected type '${expectedType}' but got '${actualType}'`, inputs);
+          }
+        } else if (expectedType === "array") {
+          if (!Array.isArray(value)) {
+            throw new ValidationError("input", "TOOL_INPUT_VALIDATION_FAILED", `Workflow input validation failed: input '${key}' expected type 'array' but got '${actualType}'`, inputs);
+          }
+        } else if (actualType !== expectedType) {
+          throw new ValidationError("input", "TOOL_INPUT_VALIDATION_FAILED", `Workflow input validation failed: input '${key}' expected type '${expectedType}' but got '${actualType}'`, inputs);
+        }
+      }
+    }
+  }
+}
+function validateWorkflowOutput(outputSchema, output, endStepId) {
+  const expectedType = outputSchema.type;
+  if (typeof expectedType === "string") {
+    if (expectedType === "object" && (typeof output !== "object" || output === null)) {
+      throw new ValidationError(endStepId, "WORKFLOW_OUTPUT_VALIDATION_FAILED", `Workflow output validation failed: expected type 'object' but got '${output === null ? "null" : typeof output}'`, output);
+    }
+    if (expectedType === "array" && !Array.isArray(output)) {
+      throw new ValidationError(endStepId, "WORKFLOW_OUTPUT_VALIDATION_FAILED", `Workflow output validation failed: expected type 'array' but got '${typeof output}'`, output);
+    }
+    if ((expectedType === "string" || expectedType === "boolean") && typeof output !== expectedType) {
+      throw new ValidationError(endStepId, "WORKFLOW_OUTPUT_VALIDATION_FAILED", `Workflow output validation failed: expected type '${expectedType}' but got '${typeof output}'`, output);
+    }
+    if ((expectedType === "number" || expectedType === "integer") && typeof output !== "number") {
+      throw new ValidationError(endStepId, "WORKFLOW_OUTPUT_VALIDATION_FAILED", `Workflow output validation failed: expected type '${expectedType}' but got '${typeof output}'`, output);
+    }
+  }
+  if (typeof output === "object" && output !== null && !Array.isArray(output)) {
+    const required = outputSchema.required;
+    if (Array.isArray(required)) {
+      const missing = required.filter((key) => typeof key === "string" && !(key in output));
+      if (missing.length > 0) {
+        throw new ValidationError(endStepId, "WORKFLOW_OUTPUT_VALIDATION_FAILED", `Workflow output validation failed: missing required field(s): ${missing.join(", ")}`, output);
+      }
+    }
+    const properties = outputSchema.properties;
+    if (properties && typeof properties === "object") {
+      for (const [key, value] of Object.entries(output)) {
+        const propSchema = properties[key];
+        if (propSchema && typeof propSchema === "object" && "type" in propSchema) {
+          const propExpectedType = propSchema.type;
+          const actualType = typeof value;
+          if (propExpectedType === "integer" || propExpectedType === "number") {
+            if (actualType !== "number") {
+              throw new ValidationError(endStepId, "WORKFLOW_OUTPUT_VALIDATION_FAILED", `Workflow output validation failed: field '${key}' expected type '${propExpectedType}' but got '${actualType}'`, output);
+            }
+          } else if (propExpectedType === "array") {
+            if (!Array.isArray(value)) {
+              throw new ValidationError(endStepId, "WORKFLOW_OUTPUT_VALIDATION_FAILED", `Workflow output validation failed: field '${key}' expected type 'array' but got '${actualType}'`, output);
+            }
+          } else if (actualType !== propExpectedType) {
+            throw new ValidationError(endStepId, "WORKFLOW_OUTPUT_VALIDATION_FAILED", `Workflow output validation failed: field '${key}' expected type '${propExpectedType}' but got '${actualType}'`, output);
+          }
+        }
+      }
+    }
+  }
+}
+function resolveStepInputs(step, scope) {
+  switch (step.type) {
+    case "tool-call":
+      return resolveToolCallInputs(step, scope);
+    case "llm-prompt":
+      return resolveLlmPromptInputs(step, scope);
+    case "extract-data":
+      return resolveExtractDataInputs(step, scope);
+    case "switch-case":
+      return resolveSwitchCaseInputs(step, scope);
+    case "for-each":
+      return resolveForEachInputs(step, scope);
+    case "agent-loop":
+      return resolveAgentLoopInputs(step, scope);
+    default:
+      return;
+  }
+}
+async function executeStep(step, scope, stepIndex, stepOutputs, loopVars, options, context, timer, stateManager, execPath = []) {
+  switch (step.type) {
+    case "llm-prompt":
+      return executeLlmPrompt(step, scope, options);
+    case "extract-data":
+      return executeExtractData(step, scope, options, timer.resolvedLimits);
+    case "agent-loop":
+      return executeAgentLoop(step, scope, options, timer.resolvedLimits);
+    case "tool-call":
+      return { output: await executeToolCall(step, scope, options.tools) };
+    case "switch-case":
+      return {
+        output: await executeSwitchCase(step, scope, stepIndex, stepOutputs, loopVars, options, context, stateManager, execPath, executeChain)
+      };
+    case "for-each":
+      return {
+        output: await executeForEach(step, scope, stepIndex, stepOutputs, loopVars, options, context, stateManager, execPath, executeChain)
+      };
+    case "sleep":
+      return { output: await executeSleep(step, scope, context, timer) };
+    case "wait-for-condition":
+      return {
+        output: await executeWaitForCondition(step, scope, stepIndex, stepOutputs, loopVars, options, context, timer, stateManager, execPath, executeChain)
+      };
+    case "start":
+      return { output: await executeStart() };
+    case "end":
+      return { output: await executeEnd(step, scope) };
+  }
+}
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_BASE_DELAY_MS = 1000;
+async function retryStep(step, stepIndex, stepOutputs, loopVars, options, originalError, context, timer, stateManager, execPath = []) {
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const baseDelay = options.retryDelayMs ?? DEFAULT_BASE_DELAY_MS;
+  const scope = { ...stepOutputs, ...loopVars };
+  for (let attempt = 1;attempt <= maxRetries; attempt++) {
+    const retryStartedAt = new Date().toISOString();
+    await context.sleep(`${step.id}_retry_${attempt}`, baseDelay * 2 ** (attempt - 1));
+    try {
+      return await executeStep(step, scope, stepIndex, stepOutputs, loopVars, options, context, timer, stateManager, execPath);
+    } catch (e) {
+      stateManager?.retryAttempted(step.id, execPath, {
+        attempt,
+        startedAt: retryStartedAt,
+        failedAt: new Date().toISOString(),
+        errorCode: e instanceof StepExecutionError ? e.code : "UNKNOWN",
+        errorMessage: e instanceof Error ? e.message : String(e)
+      });
+      if (attempt === maxRetries)
+        throw originalError;
+    }
+  }
+  throw originalError;
+}
+async function recoverFromError(error, step, stepIndex, stepOutputs, loopVars, options, context, timer, stateManager, execPath = []) {
+  switch (error.code) {
+    case "LLM_RATE_LIMITED":
+    case "LLM_NETWORK_ERROR":
+    case "LLM_NO_CONTENT":
+    case "LLM_OUTPUT_PARSE_ERROR":
+      return retryStep(step, stepIndex, stepOutputs, loopVars, options, error, context, timer, stateManager, execPath);
+    case "LLM_API_ERROR":
+      if (error instanceof ExternalServiceError && error.isRetryable) {
+        return retryStep(step, stepIndex, stepOutputs, loopVars, options, error, context, timer, stateManager, execPath);
+      }
+      throw error;
+    default:
+      throw error;
+  }
+}
+var executeChain = async function executeChain2(startStepId, stepIndex, stepOutputs, loopVars, options, context, timer, stateManager, execPath = []) {
+  let currentStepId = startStepId;
+  let lastOutput;
+  while (currentStepId) {
+    const step = stepIndex.get(currentStepId);
+    if (!step) {
+      throw new Error(`Step '${currentStepId}' not found`);
+    }
+    timer?.checkTotal(step.id);
+    const stepStartTime = Date.now();
+    stateManager?.stepStarted(step.id, execPath);
+    options.onStepStart?.(step.id, step);
+    const scope = { ...stepOutputs, ...loopVars };
+    const resolvedInputs = stateManager ? resolveStepInputs(step, scope) : undefined;
+    let stepResult;
+    try {
+      timer?.beginActive();
+      try {
+        stepResult = await context.step(step.id, () => executeStep(step, scope, stepIndex, stepOutputs, loopVars, options, context, timer ?? new ExecutionTimer, stateManager, execPath));
+      } finally {
+        timer?.endActive(step.id);
+      }
+    } catch (e) {
+      if (!(e instanceof StepExecutionError)) {
+        const durationMs2 = Date.now() - stepStartTime;
+        const wrappedError = new ExternalServiceError(step.id, "TOOL_EXECUTION_FAILED", e instanceof Error ? e.message : String(e), e, undefined, false);
+        stateManager?.stepFailed(step.id, execPath, wrappedError, durationMs2, resolvedInputs);
+        throw e;
+      }
+      stepResult = await recoverFromError(e, step, stepIndex, stepOutputs, loopVars, options, context, timer ?? new ExecutionTimer, stateManager, execPath);
+    }
+    const durationMs = Date.now() - stepStartTime;
+    stepOutputs[step.id] = stepResult.output;
+    lastOutput = stepResult.output;
+    stateManager?.stepCompleted(step.id, execPath, stepResult.output, durationMs, resolvedInputs, stepResult.trace);
+    options.onStepComplete?.(step.id, stepResult.output);
+    currentStepId = step.nextStepId;
+  }
+  return lastOutput;
+};
+function validateWorkflowConfig(workflow, options) {
+  const needsAgent = workflow.steps.some((s) => s.type === "llm-prompt" || s.type === "extract-data" || s.type === "agent-loop");
+  if (needsAgent && !options.model) {
+    const llmStep = workflow.steps.find((s) => s.type === "llm-prompt" || s.type === "extract-data" || s.type === "agent-loop");
+    throw new ConfigurationError(llmStep?.id ?? "unknown", "AGENT_NOT_PROVIDED", "Workflow contains LLM/agent steps but no agent was provided");
+  }
+  for (const step of workflow.steps) {
+    if (step.type === "tool-call") {
+      const toolDef = options.tools[step.params.toolName];
+      if (!toolDef) {
+        throw new ConfigurationError(step.id, "TOOL_NOT_FOUND", `Tool '${step.params.toolName}' not found`);
+      }
+      if (!toolDef.execute) {
+        throw new ConfigurationError(step.id, "TOOL_MISSING_EXECUTE", `Tool '${step.params.toolName}' has no execute function`);
+      }
+    }
+    if (step.type === "agent-loop" && !options.agent) {
+      for (const toolName of step.params.tools) {
+        const toolDef = options.tools[toolName];
+        if (!toolDef) {
+          throw new ConfigurationError(step.id, "TOOL_NOT_FOUND", `Tool '${toolName}' referenced in agent-loop step not found`);
+        }
+        if (!toolDef.execute) {
+          throw new ConfigurationError(step.id, "TOOL_MISSING_EXECUTE", `Tool '${toolName}' referenced in agent-loop step has no execute function`);
+        }
+      }
+    }
+  }
+}
+async function executeWorkflow(workflow, options) {
+  const stepIndex = new Map;
+  for (const step of workflow.steps) {
+    stepIndex.set(step.id, step);
+  }
+  const stepOutputs = {};
+  const resolvedOptions = options;
+  const resolvedContext = options.context ?? createDefaultDurableContext();
+  const timer = new ExecutionTimer(options.limits);
+  const stateManager = new ExecutionStateManager(options.onStateChange);
+  stateManager.runStarted();
+  try {
+    validateWorkflowConfig(workflow, resolvedOptions);
+    const inputs = options.inputs ?? {};
+    validateWorkflowInputs(workflow.inputSchema, inputs);
+    stepOutputs.input = inputs;
+    const chainOutput = await executeChain(workflow.initialStepId, stepIndex, stepOutputs, {}, resolvedOptions, resolvedContext, timer, stateManager, []);
+    if (workflow.outputSchema) {
+      let endStepId = "unknown";
+      for (const step of workflow.steps) {
+        if (step.type === "end" && step.id in stepOutputs) {
+          endStepId = step.id;
+        }
+      }
+      validateWorkflowOutput(workflow.outputSchema, chainOutput, endStepId);
+    }
+    stateManager.runCompleted(chainOutput);
+    return {
+      success: true,
+      stepOutputs,
+      output: chainOutput,
+      executionState: stateManager.currentState
+    };
+  } catch (e) {
+    const error = e instanceof StepExecutionError ? e : new ExternalServiceError("unknown", "TOOL_EXECUTION_FAILED", e instanceof Error ? e.message : String(e), e, undefined, false);
+    stateManager.runFailed(error);
+    return {
+      success: false,
+      stepOutputs,
+      error,
+      executionState: stateManager.currentState
+    };
+  }
+}
+// src/generator/index.ts
+import { generateText as generateText2, stepCountIs as stepCountIs4, tool as tool3 } from "ai";
+import { type as arktype2 } from "arktype";
+
+// src/types.ts
+import { type as type2 } from "arktype";
+var expressionSchema = type2({
+  type: "'literal'",
+  value: "unknown"
+}).or({
+  type: "'jmespath'",
+  expression: "string"
+}).or({
+  type: "'template'",
+  template: "string"
+}).describe("a value that must always be wrapped as an expression object — use { type: 'literal', value: ... } for any static value (strings, numbers, booleans, etc.), { type: 'jmespath', expression: '...' } for dynamic data extracted from previous steps' outputs (via their step ids, e.g. `stepId.someKey`) or loop variables (e.g. `itemName.someKey` within a for-each loop body), or { type: 'template', template: '...' } for string interpolation with embedded JMESPath expressions using ${...} syntax (e.g. 'Hello ${user.name}, order ${order.id}') — template expressions always resolve to a string");
+var toolCallParamsSchema = type2({
+  type: "'tool-call'",
+  params: {
+    toolName: "string",
+    toolInput: [
+      {
+        "[string]": expressionSchema
+      },
+      "@",
+      "a map of input parameter names to their values; ALL values must be wrapped as expression objects — even static strings like email addresses must use { type: 'literal', value: '...' }, never plain primitives"
+    ]
+  }
+}).describe("a step that calls a tool with specified input parameters (which can be static values or expressions)");
+var switchCaseParamsSchema = type2({
+  type: "'switch-case'",
+  params: {
+    switchOn: expressionSchema,
+    cases: [
+      {
+        value: expressionSchema.or({ type: "'default'" }),
+        branchBodyStepId: [
+          "string",
+          "@",
+          "the id of the first step in the branch body chain to execute if this case matches"
+        ]
+      },
+      "[]"
+    ]
+  }
+}).describe("a step that branches to different step chains based on the value of an expression; each case's chain runs until a step with no nextStepId, at which point execution continues with this step's nextStepId; a case with type 'default' serves as the fallback if no other case matches");
+var forEachParamsSchema = type2({
+  type: "'for-each'",
+  params: {
+    target: expressionSchema,
+    itemName: [
+      "string",
+      "@",
+      "the name to refer to the current item in the list within expressions in the loop body"
+    ],
+    loopBodyStepId: [
+      "string",
+      "@",
+      "the id of the first step in the loop body chain to execute for each item in the list"
+    ]
+  }
+}).describe("a step that iterates over a list and executes a chain of steps for each item; the loop body chain runs until a step with no nextStepId, at which point the next iteration begins; once all items are exhausted, execution continues with this step's nextStepId");
+var llmPromptSchema = type2({
+  type: "'llm-prompt'",
+  params: {
+    prompt: [
+      "string",
+      "@",
+      "a template string where JMESPath expressions can be embedded using ${...} syntax (e.g. 'Hello ${user.name}, you have ${length(user.messages)} messages'). All data from previous steps is available via their step ids (e.g. ${stepId.someKey}), and loop variables are available within for-each loop bodies (e.g. ${itemName.someKey})"
+    ],
+    outputFormat: [
+      "object",
+      "@",
+      "JSON schema specifying the output format expected from the LLM"
+    ]
+  }
+}).describe("a step that prompts an LLM with a text prompt to produce an output in a specified format");
+var extractDataParamsSchema = type2({
+  type: "'extract-data'",
+  params: {
+    sourceData: [expressionSchema, "@", "the data to extract information from"],
+    outputFormat: [
+      "object",
+      "@",
+      "JSON schema specifying the output format expected from the data extraction"
+    ]
+  }
+}).describe("a step that uses an LLM to extract structured data from a larger blob of source data (e.g. llm responses or tool outputs with unknown output formats) based on a specified output format");
+var sleepParamsSchema = type2({
+  type: "'sleep'",
+  params: {
+    durationMs: expressionSchema
+  }
+}).describe("a step that pauses workflow execution for a specified duration in milliseconds; the durationMs parameter must evaluate to a non-negative number");
+var waitForConditionParamsSchema = type2({
+  type: "'wait-for-condition'",
+  params: {
+    conditionStepId: [
+      "string",
+      "@",
+      "the id of the first step in the condition-check chain that will be executed on each polling attempt; this chain runs until a step with no nextStepId, then the condition expression is evaluated"
+    ],
+    condition: [
+      expressionSchema,
+      "@",
+      "an expression evaluated after each execution of the condition-check chain; if it evaluates to a truthy value, the wait completes with that value as its output; all step outputs from the condition chain are available in scope for this expression"
+    ],
+    "maxAttempts?": [
+      expressionSchema,
+      "@",
+      "maximum number of polling attempts before giving up (default: 10)"
+    ],
+    "intervalMs?": [
+      expressionSchema,
+      "@",
+      "milliseconds to wait between polling attempts (default: 1000)"
+    ],
+    "backoffMultiplier?": [
+      expressionSchema,
+      "@",
+      "multiply the interval by this factor after each attempt (default: 1, i.e. no backoff; use 2 for exponential backoff)"
+    ],
+    "timeoutMs?": [
+      expressionSchema,
+      "@",
+      "hard timeout in milliseconds; if the total elapsed time exceeds this, the step fails regardless of remaining attempts"
+    ]
+  }
+}).describe("a step that repeatedly executes a condition-check chain (starting at conditionStepId) and then evaluates the condition expression against the updated scope; if the condition expression evaluates to a truthy value, the step completes with that value as its output; otherwise it waits for intervalMs milliseconds (multiplied by backoffMultiplier after each attempt) and tries again, up to maxAttempts times or until timeoutMs milliseconds have elapsed; the condition-check chain runs until a step with no nextStepId, at which point the condition expression is evaluated; all step outputs from the condition chain are available in scope for the condition expression");
+var agentLoopParamsSchema = type2({
+  type: "'agent-loop'",
+  params: {
+    instructions: [
+      "string",
+      "@",
+      "a template string with task instructions for the agent; JMESPath expressions can be embedded using ${...} syntax (e.g. 'Research ${input.topic} and summarize findings'). All data from previous steps is available via their step ids, and loop variables are available within for-each loop bodies"
+    ],
+    tools: [
+      ["string", "[]"],
+      "@",
+      "names of tools from the workflow's tool set that the agent is allowed to use"
+    ],
+    outputFormat: [
+      "object",
+      "@",
+      "JSON schema specifying the structured output format expected from the agent"
+    ],
+    "maxSteps?": [
+      expressionSchema,
+      "@",
+      "maximum number of tool-calling steps the agent may take (default: 10)"
+    ]
+  }
+}).describe("a step that delegates work to an autonomous agent with its own tool-calling loop; USE SPARINGLY — this sacrifices the determinism that is the core value of the workflow DSL. Prefer explicit tool-call, llm-prompt, and control flow steps whenever the task can be decomposed into predictable operations");
+var startParamsSchema = type2({
+  type: "'start'"
+}).describe("a step that marks the entry point of a workflow; a no-op marker whose execution continues to the next step");
+var endSchema = type2({
+  type: "'end'",
+  "params?": {
+    output: expressionSchema
+  }
+}).describe("a step that indicates the end of a branch; optionally specify an output expression whose evaluated value becomes the workflow's output");
+var workflowStepSchema = type2({
+  id: /^[a-zA-Z_][a-zA-Z0-9_]+$/,
+  name: "string",
+  description: "string",
+  "nextStepId?": "string"
+}).and(toolCallParamsSchema.or(llmPromptSchema).or(extractDataParamsSchema).or(switchCaseParamsSchema).or(forEachParamsSchema).or(sleepParamsSchema).or(waitForConditionParamsSchema).or(agentLoopParamsSchema).or(startParamsSchema).or(endSchema));
+var workflowDefinitionSchema = type2({
+  initialStepId: "string",
+  "inputSchema?": [
+    "object",
+    "@",
+    "an optional JSON Schema object defining the inputs required to run the workflow; the executor validates provided inputs against this schema, and the validated inputs become available in JMESPath scope via the root identifier 'input' (e.g. input.fieldName)"
+  ],
+  "outputSchema?": [
+    "object",
+    "@",
+    "an optional JSON Schema object declaring the shape of the workflow's output; when present, the value produced by the end step's output expression will be validated against this schema"
+  ],
+  steps: [
+    [workflowStepSchema, "[]"],
+    "@",
+    "a list of steps to execute in the workflow; these should be in no particular order as execution flow is determined by the nextStepId fields and branching logic within the steps"
+  ]
+});
+
+// src/generator/prompt.ts
+import { asSchema as asSchema2 } from "ai";
+async function serializeToolsForPrompt(tools) {
+  return JSON.stringify(await Promise.all(Object.entries(tools).map(async ([toolName, toolDef]) => ({
+    name: toolName,
+    description: toolDef.description,
+    inputSchema: await asSchema2(toolDef.inputSchema).jsonSchema,
+    outputSchema: toolDef.outputSchema ? await asSchema2(toolDef.outputSchema).jsonSchema : undefined
+  }))));
+}
+function buildWorkflowGenerationPrompt(serializedTools, additionalInstructions) {
+  return `You are a workflow architect. Your job is to design a workflow definition in the remora DSL that accomplishes a given task using the provided tools. You MUST call the createWorkflow tool with a valid workflow definition.
+
+## Workflow Structure
+
+A workflow has:
+- \`initialStepId\`: the id of the first step to execute
+- \`inputSchema\` (optional): a JSON Schema object defining the inputs required to run the workflow. When present, provided inputs are validated against this schema and become available in JMESPath expressions via the root identifier \`input\` (e.g. \`input.fieldName\`).
+- \`outputSchema\` (optional): a JSON Schema object declaring the shape of the workflow's output. When present, every \`end\` step should have an \`output\` expression that evaluates to a value matching this schema.
+- \`steps\`: an array of step objects (order does not matter — execution flow is determined by nextStepId links)
+
+## Step Common Fields
+
+Every step has:
+- \`id\`: unique identifier matching /^[a-zA-Z_][a-zA-Z0-9_]+$/ (letters, digits, underscores; at least 2 characters)
+- \`name\`: human-readable name
+- \`description\`: what this step does
+- \`type\`: one of the step types below
+- \`nextStepId\` (optional): id of the next step to execute after this one
+
+## Step Types
+
+### start
+A no-op marker that indicates the entry point of a workflow. It takes no parameters. Workflow inputs are declared via \`inputSchema\` on the workflow definition itself, not on the start step.
+\`\`\`json
+{
+  "type": "start"
+}
+\`\`\`
+
+### tool-call
+Calls a tool with input parameters. All values in toolInput MUST be expression objects.
+\`\`\`json
+{
+  "type": "tool-call",
+  "params": {
+    "toolName": "name-of-tool",
+    "toolInput": {
+      "paramName": { "type": "literal", "value": "static value" },
+      "otherParam": { "type": "jmespath", "expression": "previous_step.someField" }
+    }
+  }
+}
+\`\`\`
+
+### llm-prompt
+Prompts an LLM with a template string to produce structured output. Use \${...} syntax to embed JMESPath expressions in the prompt.
+\`\`\`json
+{
+  "type": "llm-prompt",
+  "params": {
+    "prompt": "Classify this ticket: \${get_tickets.tickets[0].subject}",
+    "outputFormat": { "type": "object", "properties": { "category": { "type": "string" } }, "required": ["category"] }
+  }
+}
+\`\`\`
+
+### extract-data
+Uses an LLM to extract structured data from a source. Use when you need to parse unstructured or semi-structured data into a known shape.
+\`\`\`json
+{
+  "type": "extract-data",
+  "params": {
+    "sourceData": { "type": "jmespath", "expression": "previous_step.rawContent" },
+    "outputFormat": { "type": "object", "properties": { ... }, "required": [...] }
+  }
+}
+\`\`\`
+
+### switch-case
+Branches execution based on a value. Each case's branch chain runs until a step with no nextStepId, then execution continues with this step's nextStepId. Use \`{ "type": "default" }\` for a fallback case.
+\`\`\`json
+{
+  "type": "switch-case",
+  "params": {
+    "switchOn": { "type": "jmespath", "expression": "classify.category" },
+    "cases": [
+      {
+        "value": { "type": "literal", "value": "critical" },
+        "branchBodyStepId": "handle_critical"
+      },
+      {
+        "value": { "type": "default" },
+        "branchBodyStepId": "handle_other"
+      }
+    ]
+  }
+}
+\`\`\`
+
+### for-each
+Iterates over a list and executes a chain of steps for each item. The loop body chain runs until a step with no nextStepId, then the next iteration begins. After all items, execution continues with this step's nextStepId. The \`itemName\` becomes a scoped variable accessible only within the loop body.
+\`\`\`json
+{
+  "type": "for-each",
+  "params": {
+    "target": { "type": "jmespath", "expression": "get_items.items" },
+    "itemName": "item",
+    "loopBodyStepId": "process_item"
+  }
+}
+\`\`\`
+
+### sleep
+Pauses workflow execution for a fixed duration. Use when you need to wait between operations (e.g., rate limiting, propagation delays).
+\`\`\`json
+{
+  "type": "sleep",
+  "params": {
+    "durationMs": { "type": "literal", "value": 5000 }
+  }
+}
+\`\`\`
+
+### wait-for-condition
+Repeatedly executes a condition-check chain and evaluates a condition expression until it returns a truthy value. Use when you need to poll for a state change (e.g., waiting for a job to complete, a resource to become available).
+
+The \`conditionStepId\` points to the first step of a sub-chain that will be executed on each polling attempt. After the chain runs, the \`condition\` expression is evaluated against the current scope (including all outputs from the condition chain). If the result is truthy, the wait-for-condition step completes with that value as its output. Otherwise, it waits and retries.
+
+Optional parameters control polling behavior:
+- \`maxAttempts\`: maximum number of polling attempts (default: 10)
+- \`intervalMs\`: milliseconds between attempts (default: 1000)
+- \`backoffMultiplier\`: multiply interval by this after each attempt (default: 1, i.e. no backoff; use 2 for exponential)
+- \`timeoutMs\`: hard timeout in milliseconds (optional)
+\`\`\`json
+{
+  "type": "wait-for-condition",
+  "params": {
+    "conditionStepId": "poll_status",
+    "condition": { "type": "jmespath", "expression": "poll_status.status == 'complete'" },
+    "maxAttempts": { "type": "literal", "value": 30 },
+    "intervalMs": { "type": "literal", "value": 2000 },
+    "backoffMultiplier": { "type": "literal", "value": 1.5 },
+    "timeoutMs": { "type": "literal", "value": 120000 }
+  }
+}
+\`\`\`
+
+### agent-loop
+**USE SPARINGLY.** Delegates work to an autonomous agent with its own tool-calling loop. This step sacrifices the determinism that is the core value of the workflow DSL. Only use when the task genuinely cannot be decomposed into predictable tool-call, llm-prompt, and control flow steps (e.g., open-ended research tasks, complex multi-step reasoning that depends on intermediate results in unpredictable ways).
+
+The agent receives the interpolated \`instructions\` as a prompt, has access to the listed \`tools\`, and must produce output matching \`outputFormat\`. The \`maxSteps\` parameter bounds the number of tool-calling iterations (default: 10).
+\`\`\`json
+{
+  "type": "agent-loop",
+  "params": {
+    "instructions": "Research \${input.topic} using the available search tools and compile a summary with at least 3 sources.",
+    "tools": ["web_search", "fetch_page"],
+    "outputFormat": {
+      "type": "object",
+      "properties": {
+        "summary": { "type": "string" },
+        "sources": { "type": "array", "items": { "type": "string" } }
+      },
+      "required": ["summary", "sources"]
+    },
+    "maxSteps": { "type": "literal", "value": 15 }
+  }
+}
+\`\`\`
+
+### end
+Marks the end of a branch or the workflow. Must NOT have a nextStepId. Optionally, specify an output expression whose value becomes the workflow's return value.
+\`\`\`json
+{
+  "type": "end"
+}
+\`\`\`
+
+With output (when the workflow declares an outputSchema):
+\`\`\`json
+{
+  "type": "end",
+  "params": {
+    "output": { "type": "jmespath", "expression": "summarize.result" }
+  }
+}
+\`\`\`
+
+## Expression System
+
+Every dynamic value must be an expression object:
+
+1. **Literal** — for static values known at design time:
+   \`{ "type": "literal", "value": <any value> }\`
+
+2. **JMESPath** — for referencing data from previous steps, workflow inputs, or loop variables:
+   \`{ "type": "jmespath", "expression": "<expression>" }\`
+   The root of a JMESPath expression must be one of: the \`input\` alias (e.g. \`input.orderId\`) for workflow inputs, a step id (e.g. \`get_orders.orders\`) for previous step outputs, or a loop variable name (e.g. \`item.id\` within a for-each body).
+
+3. **Template strings** (llm-prompt only) — embed JMESPath in the prompt string using \${...}:
+   \`"Summarize: \${fetch_data.content}"\`
+   These are NOT expression objects — they appear directly in the prompt string.
+
+## Structural Rules
+
+1. Step IDs must be unique and match /^[a-zA-Z_][a-zA-Z0-9_]+$/.
+2. Steps link via nextStepId. Omitting nextStepId ends the chain.
+3. Branch body chains (switch-case), loop body chains (for-each), and condition body chains (wait-for-condition) must terminate — their last step must NOT have a nextStepId. Do NOT point them back to the parent or outside the body.
+4. Only reference step IDs of steps that will have executed before the current step (no forward references).
+5. Do not create cycles (for-each handles iteration — you do not need to loop manually).
+6. end steps must NOT have a nextStepId.
+
+## Available Tools
+
+Each tool below includes an \`outputSchema\` describing the shape of its return value. Use the output schema to construct correct JMESPath expressions. For example, if a tool returns \`{ "type": "object", "properties": { "orders": { "type": "array", ... } } }\`, reference the array as \`step_id.orders\`, not \`step_id\` alone.
+
+${serializedTools}
+
+## Common Mistakes
+
+1. NEVER use bare primitives in toolInput. ALL values must be expression objects.
+   WRONG: \`{ "email": "user@example.com" }\`
+   RIGHT: \`{ "email": { "type": "literal", "value": "user@example.com" } }\`
+
+2. Do NOT give end steps a nextStepId.
+
+3. Branch/loop body chains must terminate (last step has no nextStepId). Do NOT point them outside their scope.
+
+4. JMESPath expressions reference step outputs by step ID as the root identifier (e.g. \`"get_orders.orders[0].id"\`), and workflow inputs via the \`input\` alias (e.g. \`"input.orderId"\`).
+
+5. For-each itemName is a scoped variable accessible ONLY within the loop body steps.
+
+6. Step IDs must be at least 2 characters long.
+
+7. for-each target must resolve to an ARRAY. Check the tool's outputSchema to determine the correct path.
+   WRONG: \`"target": { "type": "jmespath", "expression": "get_orders" }\` (when get_orders returns an object with an \`orders\` array property)
+   RIGHT: \`"target": { "type": "jmespath", "expression": "get_orders.orders" }\`
+
+8. If the workflow needs to return structured data, declare an \`outputSchema\` on the workflow and give every \`end\` step an \`output\` expression that evaluates to a value matching it.
+
+9. wait-for-condition requires both \`conditionStepId\` (the chain to execute on each polling attempt) AND \`condition\` (the expression to evaluate after the chain runs). The condition expression is evaluated AFTER the chain runs, using the updated scope with all step outputs from the condition chain.
+
+10. Prefer explicit tool-call, llm-prompt, switch-case, and for-each steps over agent-loop. Only use agent-loop when the task is genuinely open-ended and cannot be decomposed into deterministic steps.${additionalInstructions ? `
+
+## Additional Instructions
+
+${additionalInstructions}` : ""}`;
+}
+function formatDiagnostics(diagnostics) {
+  const errors = diagnostics.filter((d) => d.severity === "error");
+  if (errors.length === 0)
+    return "No errors.";
+  return errors.map((d) => {
+    const loc = d.location ? ` (at step ${d.location.stepId}${d.location.field ? `, field ${d.location.field}` : ""})` : "";
+    return `- [${d.code}] ${d.message}${loc}`;
+  }).join(`
+`);
+}
+
+// src/generator/index.ts
+async function generateWorkflow(options) {
+  const {
+    model,
+    tools,
+    task,
+    maxRetries = 3,
+    additionalInstructions
+  } = options;
+  const missingOutputSchema = Object.entries(tools).filter(([_, t]) => !t.outputSchema).map(([name]) => name);
+  if (missingOutputSchema.length > 0) {
+    throw new Error(`All tools must have an outputSchema. Missing: ${missingOutputSchema.join(", ")}`);
+  }
+  const serializedTools = await serializeToolsForPrompt(tools);
+  const systemPrompt = buildWorkflowGenerationPrompt(serializedTools, additionalInstructions);
+  let successWorkflow = null;
+  let lastDiagnostics = [];
+  let attempts = 0;
+  const createWorkflowTool = tool3({
+    description: "Create a workflow definition",
+    inputSchema: workflowDefinitionSchema,
+    execute: async (workflowDef) => {
+      attempts++;
+      const result = await compileWorkflow(workflowDef, { tools });
+      lastDiagnostics = result.diagnostics;
+      const errors = result.diagnostics.filter((d) => d.severity === "error");
+      if (errors.length > 0) {
+        return {
+          success: false,
+          errors: formatDiagnostics(result.diagnostics)
+        };
+      }
+      successWorkflow = result.workflow ?? workflowDef;
+      return { success: true };
+    }
+  });
+  await generateText2({
+    model,
+    system: systemPrompt,
+    prompt: `Create a workflow to accomplish the following task:
+
+${task}`,
+    tools: { createWorkflow: createWorkflowTool },
+    toolChoice: { type: "tool", toolName: "createWorkflow" },
+    stopWhen: [stepCountIs4(maxRetries + 1), () => successWorkflow !== null]
+  });
+  return {
+    workflow: successWorkflow,
+    diagnostics: lastDiagnostics,
+    attempts
+  };
+}
+function createWorkflowGeneratorTool(options) {
+  const {
+    model,
+    tools: baseTools,
+    maxRetries,
+    additionalInstructions
+  } = options;
+  return tool3({
+    description: "Generate a validated workflow definition from a natural language task description",
+    inputSchema: arktype2({ task: "string" }),
+    execute: async ({ task }) => {
+      return generateWorkflow({
+        model,
+        tools: baseTools ?? {},
+        task,
+        maxRetries,
+        additionalInstructions
+      });
+    }
+  });
+}
+export {
+  workflowDefinitionSchema,
+  snapshotError,
+  serializeToolsForPrompt,
+  generateWorkflow,
+  executeWorkflow,
+  createWorkflowGeneratorTool,
+  createDefaultDurableContext,
+  compileWorkflow,
+  buildWorkflowGenerationPrompt,
+  applyDelta,
+  ValidationError,
+  StepExecutionError,
+  OutputQualityError,
+  ExternalServiceError,
+  ExpressionError,
+  ConfigurationError
+};
+
+//# debugId=0F518A409A3FE44264756E2164756E21