@axiom-lattice/core 2.1.80 → 2.1.81

package/dist/{chunk-FN4TRQK4.mjs → chunk-SGRFQY3E.mjs}

@@ -10,6 +10,300 @@ import {
   Annotation
 } from "@langchain/langgraph";
 import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+
+// src/workflow/parse-yaml.ts
+import * as yaml from "js-yaml";
+
+// src/workflow/schema.ts
+function toJsonSchema(fields) {
+  if (!fields || Object.keys(fields).length === 0) return void 0;
+  const properties = {};
+  const required = [];
+  for (const [key, value] of Object.entries(fields)) {
+    required.push(key);
+    properties[key] = fieldToSchema(value);
+  }
+  return { type: "object", properties, required };
+}
+function fieldToSchema(value) {
+  if (typeof value === "string") return stringTypeToSchema(value);
+  if (Array.isArray(value) && value.length > 0 && typeof value[0] === "object" && !Array.isArray(value[0])) {
+    const nested = toJsonSchema(value[0]);
+    return { type: "array", items: nested ?? { type: "object" } };
+  }
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const nested = toJsonSchema(value);
+    return nested ?? { type: "object" };
+  }
+  return { type: "string" };
+}
+function stringTypeToSchema(type) {
+  if (type.endsWith("[]")) {
+    const inner = type.slice(0, -2);
+    return { type: "array", items: stringTypeToSchema(inner) };
+  }
+  if (type === "string") return { type: "string" };
+  if (type === "number") return { type: "number" };
+  if (type === "boolean") return { type: "boolean" };
+  return { type };
+}
+
+// src/workflow/parse-yaml.ts
+function nodeId(label) {
+  return `n_${label}`;
+}
+var _parallelSeq = 0;
+function nextParallelLabel() {
+  return `parallel_${_parallelSeq++}`;
+}
+function translate(template) {
+  return template.replace(/\{\{([^}]+)\}\}/g, (_m, expr) => {
+    const t = expr.trim();
+    if (t === "item") return "${item}";
+    return `\${state.${t}}`;
+  });
+}
+function toSafeStateExpr(expr) {
+  const match = expr.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)/);
+  if (!match) return `state.${expr}`;
+  const field = match[0];
+  const rest = expr.slice(field.length);
+  return `state["${field}"]${rest}`;
+}
+function validateExpression(expr) {
+  if (/;/.test(expr)) {
+    throw new Error(`Condition expression must not contain semicolons: "${expr}"`);
+  }
+  if (/[{}]/.test(expr)) {
+    throw new Error(`Condition expression must not contain braces: "${expr}"`);
+  }
+  if (/\bfunction\b/.test(expr)) {
+    throw new Error(`Condition expression must not contain 'function': "${expr}"`);
+  }
+  if (/\brequire\b|\bimport\b|\bmodule\b/.test(expr)) {
+    throw new Error(`Condition expression must not contain require/import: "${expr}"`);
+  }
+  if (/\bprocess\b|\bglobal\b|\bglobalThis\b/.test(expr)) {
+    throw new Error(`Condition expression must not contain process/global: "${expr}"`);
+  }
+  if (/\beval\b|\bFunction\b/.test(expr)) {
+    throw new Error(`Condition expression must not contain eval/Function: "${expr}"`);
+  }
+  if (/\bconstructor\b|\b__proto__\b|\bprototype\b/.test(expr)) {
+    throw new Error(`Condition expression must not contain prototype access: "${expr}"`);
+  }
+  if (/\bsetTimeout\b|\bsetInterval\b|\bbuffer\b/i.test(expr)) {
+    throw new Error(`Condition expression must not contain timer or buffer references: "${expr}"`);
+  }
+}
+function parseYaml(yamlStr) {
+  _parallelSeq = 0;
+  let raw;
+  try {
+    raw = yaml.load(yamlStr);
+  } catch (e) {
+    const line = e?.mark?.line != null ? ` (line ${e.mark.line + 1})` : "";
+    throw new Error(`YAML parse error${line}: ${e.message || e}`);
+  }
+  if (!raw || typeof raw !== "object" || !Array.isArray(raw.steps)) {
+    throw new Error("Workflow YAML must have 'steps' (array)");
+  }
+  const name = typeof raw.name === "string" ? raw.name : "workflow";
+  const wf = {
+    name,
+    steps: raw.steps.map((s, i) => parseStep(s, i))
+  };
+  return normalize(wf);
+}
+function parseStep(raw, index) {
+  if (raw.parallel !== void 0) {
+    if (!Array.isArray(raw.parallel)) {
+      throw new Error(`Step at position ${index}: parallel must be an array`);
+    }
+    const children = raw.parallel.map((c, ci) => {
+      const entries2 = Object.entries(c);
+      if (entries2.length !== 1) {
+        throw new Error(`Parallel child at position ${index}.${ci} must be a single-key mapping`);
+      }
+      const [label, config2] = entries2[0];
+      return {
+        label,
+        if: config2.if !== void 0 ? String(config2.if) : void 0,
+        prompt: String(config2.prompt ?? ""),
+        output: config2.output,
+        ask: config2.ask === true
+      };
+    });
+    return {
+      parallel: children,
+      if: raw.if !== void 0 ? String(raw.if) : void 0,
+      output: raw.output
+    };
+  }
+  const entries = Object.entries(raw);
+  if (entries.length !== 1) {
+    throw new Error(`Step at position ${index} must be a single-key mapping`);
+  }
+  const [key, config] = entries[0];
+  const mapConfig = config?.map;
+  if (mapConfig && typeof mapConfig === "object") {
+    return {
+      map: {
+        source: mapConfig.source,
+        label: key,
+        // always use the YAML key as the label
+        if: mapConfig.if !== void 0 ? String(mapConfig.if) : void 0,
+        each: {
+          prompt: String(mapConfig.each?.prompt ?? ""),
+          output: mapConfig.each?.output
+        },
+        output: mapConfig.output,
+        batch: mapConfig.batch,
+        concurrency: mapConfig.concurrency
+      }
+    };
+  }
+  if (key === "map") {
+    throw new Error(`Map steps must use named format: - <label>: { map: { source, each, ... } }. Anonymous "- map:" is not supported.`);
+  }
+  return {
+    label: key,
+    if: config.if !== void 0 ? String(config.if) : void 0,
+    prompt: String(config.prompt ?? ""),
+    output: config.output,
+    ask: config.ask === true
+  };
+}
+function normalize(wf) {
+  validate(wf);
+  for (const step of wf.steps) {
+    if ("label" in step) {
+      const s = step;
+      if (s.if) validateExpression(s.if);
+    } else if ("parallel" in step) {
+      const pb = step;
+      if (pb.if) validateExpression(pb.if);
+      for (const child of pb.parallel) {
+        if (child.if) validateExpression(child.if);
+      }
+    }
+  }
+  const nodes = [];
+  const edges = [];
+  const fields = { input: { type: "string" } };
+  nodes.push({ id: "n_input", type: "input", name: "input", output: { key: "input" } });
+  edges.push({ from: "START", to: "n_input" });
+  let prevNodeId = "n_input";
+  for (const step of wf.steps) {
+    if ("label" in step) {
+      const s = step;
+      const nid = nodeId(s.label);
+      const schema = toJsonSchema(s.output);
+      nodes.push({
+        id: nid,
+        type: "agent",
+        name: s.label,
+        input: { template: translate(s.prompt) },
+        output: { key: s.label, ...schema ? { schema } : {} },
+        ask: s.ask,
+        condition: s.if
+      });
+      fields[s.label] = s.output ? { type: "object" } : { type: "string" };
+      addPrevEdges(edges, prevNodeId, nid);
+      prevNodeId = nid;
+    } else if ("parallel" in step) {
+      const pb = step;
+      const groupId = nextParallelLabel();
+      const groupNodeIds = [];
+      for (const child of pb.parallel) {
+        const nid = nodeId(child.label);
+        const schema = toJsonSchema(child.output);
+        nodes.push({
+          id: nid,
+          type: "agent",
+          name: child.label,
+          input: { template: translate(child.prompt) },
+          output: { key: child.label, ...schema ? { schema } : {} },
+          ask: child.ask,
+          condition: child.if,
+          parallelGroup: groupId
+        });
+        fields[child.label] = child.output ? { type: "object" } : { type: "string" };
+        groupNodeIds.push(nid);
+      }
+      addPrevEdges(edges, prevNodeId, groupNodeIds);
+      prevNodeId = groupNodeIds;
+    } else if ("map" in step) {
+      const ms = step.map;
+      const label = ms.label;
+      const nid = nodeId(label);
+      const innerSchema = toJsonSchema(ms.each?.output);
+      const mapSchema = toJsonSchema(ms.output);
+      nodes.push({
+        id: nid,
+        type: "map",
+        name: label,
+        source: `state.${ms.source}`,
+        itemKey: "item",
+        config: {
+          batchSize: ms.batch ?? 50,
+          maxConcurrency: ms.concurrency ?? 5,
+          innerConcurrency: ms.concurrency ?? 5
+        },
+        node: {
+          type: "agent",
+          input: ms.each?.prompt ? { template: translate(ms.each.prompt) } : void 0,
+          ...innerSchema ? { schema: innerSchema } : {}
+        },
+        output: { key: label, ...mapSchema ? { schema: mapSchema } : {} },
+        condition: ms.if
+      });
+      fields[label] = { type: "array", default: [] };
+      addPrevEdges(edges, prevNodeId, nid);
+      prevNodeId = nid;
+    }
+  }
+  const termNid = nodeId("__end");
+  nodes.push({ id: termNid, type: "terminal", name: "__end", status: "success" });
+  addPrevEdges(edges, prevNodeId, termNid);
+  return { version: "1.0", name: wf.name || "workflow", state: { fields }, nodes, edges };
+}
+function addPrevEdges(edges, fromNodes, toNodes) {
+  const fromList = Array.isArray(fromNodes) ? fromNodes : [fromNodes];
+  const toList = Array.isArray(toNodes) ? toNodes : [toNodes];
+  for (const from of fromList) {
+    for (const to of toList) {
+      if (!edges.some((e) => e.from === from && e.to === to)) {
+        edges.push({ from, to });
+      }
+    }
+  }
+}
+function validate(wf) {
+  const labels = /* @__PURE__ */ new Set();
+  for (const step of wf.steps) {
+    if ("label" in step) {
+      const s = step;
+      if (labels.has(s.label)) throw new Error(`Duplicate step label "${s.label}"`);
+      labels.add(s.label);
+    } else if ("parallel" in step) {
+      const pb = step;
+      if (pb.parallel.length === 0) {
+        throw new Error("parallel block must contain at least one child step");
+      }
+      for (const child of pb.parallel) {
+        if (labels.has(child.label)) throw new Error(`Duplicate step label "${child.label}"`);
+        labels.add(child.label);
+      }
+    } else if ("map" in step) {
+      const ms = step.map;
+      if (labels.has(ms.label)) throw new Error(`Duplicate step label "${ms.label}" (map step)`);
+      labels.add(ms.label);
+    }
+  }
+}
+
+// src/workflow/utils.ts
 function buildStateAnnotation(fields) {
   const annotations = {};
   if (fields) {
@@ -296,6 +590,36 @@ function createAgentNode(node, resolveAgent, trackingStore) {
   return async (state, config) => {
     const runId = state._runId;
     const tenantId = config?.configurable?.tenantId ?? "default";
+    if (node.condition) {
+      try {
+        validateExpression(node.condition);
+        const safeExpr = toSafeStateExpr(node.condition);
+        const fn = new Function("state", `try { return ${safeExpr}; } catch { return false; }`);
+        const shouldRun = fn(state);
+        if (!shouldRun) {
+          console.log(`[WF][${node.id}] condition false, skipping "${node.name}" (${node.condition})`);
+          if (trackingStore && runId) {
+            const step = await trackingStore.upsertRunStep({
+              runId,
+              tenantId,
+              stepType: node.type,
+              stepName: node.name
+            }).catch(() => null);
+            if (step) {
+              await trackingStore.updateRunStep(runId, step.id, {
+                status: "skipped",
+                completedAt: /* @__PURE__ */ new Date()
+              }).catch(() => {
+              });
+            }
+          }
+          return { phase: node.id };
+        }
+      } catch (condErr) {
+        console.error(`[WF][${node.id}] condition eval error: ${condErr.message}`);
+        throw condErr;
+      }
+    }
     const startedAt = Date.now();
     let stepId;
     if (trackingStore && runId) {
@@ -309,7 +633,8 @@ function createAgentNode(node, resolveAgent, trackingStore) {
       console.log(`[WF][${node.id}] START "${node.name}" | hasSchema=${!!node.output?.schema}`);
       const responseFormat = node.output?.schema;
       console.log(`[WF][${node.id}] resolving agent...`);
-      const client = await resolveAgent(node.ref, responseFormat, node.type);
+      const stepType = node.ask ? "ask" : node.type;
+      const client = await resolveAgent(node.ref, responseFormat, stepType);
       console.log(`[WF][${node.id}] agent resolved, building input...`);
       const input = buildInput(
         node.input,
@@ -317,16 +642,32 @@ function createAgentNode(node, resolveAgent, trackingStore) {
         void 0,
         responseFormat ? void 0 : node.output?.schema
       );
+      if (node.ask) {
+        input.messages = [
+          new SystemMessage(
+            "Follow this exact procedure. Do NOT skip any step.\n\nSTEP 1: Read the prompt. It contains content to present to the user and a question to ask.\n\nSTEP 2: Call ask_user_to_clarify. Your question text MUST contain the ACTUAL content from the prompt.\n\nSTEP 3: The tool will pause. The user will see your questions and respond. You will receive their answers.\n\nSTEP 4: Based on the user's answers, produce your final output."
+          ),
+          ...input.messages
+        ];
+      }
       const renderedInput = input.messages[0]?.content ?? "";
       console.log(`[WF][${node.id}] === INPUT (full) ===
 ${renderedInput}
 === END INPUT ===`);
+      const subConfig = {
+        ...config,
+        configurable: {
+          ...config?.configurable ?? {},
+          thread_id: `${config?.configurable?.thread_id ?? "default"}:${node.id}`
+        }
+      };
       if (trackingStore && runId) {
         const step = await trackingStore.upsertRunStep({
           runId,
           tenantId,
           stepType: node.type,
           stepName: node.name,
+          threadId: subConfig.configurable.thread_id,
           input: { template: node.input?.template, rendered: renderedInput }
         }).catch((e) => {
           console.warn("Failed to upsert run step:", e.message);
@@ -338,13 +679,6 @@ ${renderedInput}
           });
         }
       }
-      const subConfig = {
-        ...config,
-        configurable: {
-          ...config?.configurable ?? {},
-          thread_id: `${config?.configurable?.thread_id ?? "default"}:${node.id}`
-        }
-      };
       let result;
       try {
         console.log(`[WF][${node.id}] invoking agent.invoke()...`);
@@ -441,157 +775,40 @@ ${JSON.stringify(output, null, 2)}
     }
   };
 }
-function createHumanFeedbackNode(node, resolveAgent, trackingStore) {
+function createMapNode(node, resolveAgent, trackingStore) {
   return async (state, config) => {
     const runId = state._runId;
     const tenantId = config?.configurable?.tenantId ?? "default";
-    const startedAt = Date.now();
-    let stepId;
-    if (trackingStore && runId) {
-      trackingStore.updateWorkflowRun(runId, {
-        status: "running",
-        completedAt: null
-      }).catch(() => {
-      });
-    }
-    try {
-      console.log(`[WF][${node.id}] HUMAN_FEEDBACK START "${node.config?.title || node.name}"`);
-      const responseFormat = node.output?.schema;
-      const client = await resolveAgent(void 0, responseFormat, node.type);
-      console.log(`[WF][${node.id}] agent resolved, building input...`);
-      const input = buildInput(
-        node.input,
-        state,
-        void 0,
-        responseFormat ? void 0 : node.output?.schema
-      );
-      const humanContent = input.messages[0]?.content ?? "";
-      input.messages = [
-        new SystemMessage(
-          `Follow this exact procedure. Do NOT skip any step.
-
-STEP 1: Read the prompt. It contains content to present to the user and a question to ask.
-
-STEP 2: Call ask_user_to_clarify. Your question text MUST contain the ACTUAL content from the prompt \u2014 copy-paste the relevant text, data, or facts directly into the question. A question like "Do you approve this recommendation?" is WRONG because the user has no idea what the recommendation says. Instead: "Do you approve this recommendation: [paste the actual recommendation text here]?"
-
-STEP 3: The tool will pause. The user will see your questions and respond. You will receive their answers.
-
-STEP 4: Based on the user's answers, produce your final output.`
-        ),
-        ...input.messages
-      ];
-      const renderedInput = humanContent;
-      if (trackingStore && runId) {
-        const step = await trackingStore.upsertRunStep({
-          runId,
-          tenantId,
-          stepType: node.type,
-          stepName: node.name,
-          input: { template: node.input?.template, rendered: renderedInput }
-        }).catch((e) => {
-          console.warn("Failed to upsert run step:", e.message);
-          return null;
-        });
-        stepId = step?.id;
-        if (step && step.status === "interrupted") {
-          trackingStore.updateRunStep(runId, step.id, { status: "running" }).catch(() => {
-          });
-        }
-      }
-      const subConfig = {
-        ...config,
-        configurable: {
-          ...config?.configurable ?? {},
-          thread_id: `${config?.configurable?.thread_id ?? "default"}:${node.id}`
-        }
-      };
-      console.log(`[WF][${node.id}] === INPUT (full) ===
-${renderedInput}
-=== END INPUT ===`);
-      const result = await invokeWithRetry(
-        () => client.invoke(input, subConfig),
-        node.config?.maxRetries ?? 0,
-        node.config?.retryOn,
-        node.config?.timeout
-      );
-      console.log(`[WF][${node.id}] invoke SUCCESS, extracting output...`);
-      const output = extractOutput(result);
-      console.log(`[WF][${node.id}] === OUTPUT (full) | key=${node.output?.key} ===
-${JSON.stringify(output, null, 2)}
-=== END OUTPUT ===`);
-      const update = { phase: node.id };
-      if (node.output?.key) {
-        update[node.output.key] = output;
-      }
-      if (output && typeof output === "object" && !Array.isArray(output)) {
-        Object.assign(update, output);
-      }
-      const subMessages = result.messages;
-      if (subMessages && Array.isArray(subMessages)) {
-        const aiMessages = subMessages.filter((m) => {
-          const t = typeof m._getType === "function" ? m._getType() : m.role ?? m.type;
-          return t === "ai";
-        });
-        if (aiMessages.length > 0) {
-          update.messages = aiMessages;
-        }
-      }
-      console.log(`[WF][${node.id}] DONE (${Date.now() - startedAt}ms)`);
-      if (trackingStore && runId && stepId) {
-        trackingStore.updateRunStep(runId, stepId, {
-          status: "completed",
-          output,
-          completedAt: /* @__PURE__ */ new Date(),
-          durationMs: Date.now() - startedAt
-        }).catch((e) => {
-          console.warn("Failed to update run step:", e.message);
-        });
-      }
-      return update;
-    } catch (err) {
-      if (err?.name === "GraphInterrupt") {
-        if (trackingStore && runId && stepId) {
-          trackingStore.updateRunStep(runId, stepId, {
-            status: "interrupted"
-          }).catch(() => {
-          });
-        }
-        if (trackingStore && runId) {
-          trackingStore.updateWorkflowRun(runId, {
-            status: "interrupted",
-            completedAt: null
-          }).catch(() => {
-          });
-        }
-        throw err;
-      }
-      if (trackingStore && runId) {
-        if (stepId) {
-          trackingStore.updateRunStep(runId, stepId, {
-            status: "failed",
-            errorMessage: err.message,
-            completedAt: /* @__PURE__ */ new Date(),
-            durationMs: Date.now() - startedAt
-          }).catch((e) => {
-            console.warn("Failed to update run step:", e.message);
-          });
+    if (node.condition) {
+      try {
+        validateExpression(node.condition);
+        const safeExpr = toSafeStateExpr(node.condition);
+        const fn = new Function("state", `try { return ${safeExpr}; } catch { return false; }`);
+        const shouldRun = fn(state);
+        if (!shouldRun) {
+          console.log(`[WF][${node.id}] condition false, skipping map "${node.name}" (${node.condition})`);
+          if (trackingStore && runId) {
+            const step = await trackingStore.upsertRunStep({
+              runId,
+              tenantId,
+              stepType: node.type,
+              stepName: node.name
+            }).catch(() => null);
+            if (step) {
+              await trackingStore.updateRunStep(runId, step.id, {
+                status: "skipped",
+                completedAt: /* @__PURE__ */ new Date()
+              }).catch(() => {
+              });
+            }
+          }
+          return { phase: node.id };
         }
-        trackingStore.updateWorkflowRun(runId, {
-          status: "failed",
-          errorMessage: err.message,
-          completedAt: /* @__PURE__ */ new Date()
-        }).catch((e) => {
-          console.warn("Failed to finalize WorkflowRun:", e.message);
-        });
+      } catch (condErr) {
+        console.error(`[WF][${node.id}] condition eval error: ${condErr.message}`);
+        throw condErr;
       }
-      throw err;
     }
-  };
-}
-function createMapNode(node, resolveAgent, trackingStore) {
-  return async (state, config) => {
-    const runId = state._runId;
-    const tenantId = config?.configurable?.tenantId ?? "default";
     const startedAt = Date.now();
     let stepId;
     if (trackingStore && runId) {
@@ -805,8 +1022,6 @@ function createNodeHandler(node, resolveAgent, trackingStore) {
   switch (node.type) {
     case "agent":
       return createAgentNode(node, resolveAgent, trackingStore);
-    case "human_feedback":
-      return createHumanFeedbackNode(node, resolveAgent, trackingStore);
     case "map":
       return createMapNode(node, resolveAgent, trackingStore);
     case "terminal":
@@ -825,298 +1040,13 @@ function chunk(arr, size) {
   return result;
 }
 
-// src/workflow/normalize.ts
-var _counter = 0;
-function uid(prefix) {
-  return `${prefix}_${_counter++}`;
-}
-function nodeId(stepId) {
-  return `n_${stepId}`;
-}
-function translate(template) {
-  return template.replace(/\{\{([^}]+)\}\}/g, (_m, expr) => {
-    const t = expr.trim();
-    if (t === "item") return "${item}";
-    return `\${state.${t}}`;
-  });
-}
-function inferFieldType(id) {
-  if (/s$|list|array|items|results/i.test(id)) return { type: "array", default: [] };
-  return { type: "string" };
-}
-function expandStep(step) {
-  switch (step.type ?? "agent") {
-    case "agent":
-      return expandAgent(step);
-    case "human":
-      return expandHuman(step);
-    case "condition":
-      return expandCondition(step);
-    case "map":
-      return expandMap(step);
-    case "parallel":
-      return expandParallel(step);
-    case "end":
-      return expandEnd(step);
-  }
-}
-function validateSchema(schema, stepId) {
-  if (schema.type !== "object") {
-    throw new Error(
-      `Step "${stepId}": schema.type must be "object", got "${String(schema.type)}". Use standard JSON Schema: { "type": "object", "properties": { ... } }`
-    );
-  }
-  if (!schema.properties || typeof schema.properties !== "object") {
-    throw new Error(
-      `Step "${stepId}": schema must have a "properties" object. Legacy shorthand like { "field": "string" } is not supported. Use: { "type": "object", "properties": { "field": { "type": "string" } } }`
-    );
-  }
-}
-function expandAgent(s) {
-  const sid = s.id || uid("agent");
-  const nid = nodeId(sid);
-  if (s.schema !== void 0 && s.schema !== null) {
-    if (typeof s.schema !== "object") {
-      throw new Error(
-        `Step "${sid}": schema must be a JSON Schema object, e.g. { "type": "object", "properties": { ... } }. Got ${typeof s.schema} (${JSON.stringify(s.schema)}).`
-      );
-    }
-    validateSchema(s.schema, sid);
-  }
-  const schema = s.schema && typeof s.schema === "object" ? s.schema : void 0;
-  console.log(`[WF EXPAND] agent step id="${sid}" nodeId="${nid}" | hasSchema=${!!schema}`);
-  return {
-    nodes: [{ id: nid, type: "agent", name: sid, input: { template: translate(s.prompt) }, output: { key: sid, ...schema ? { schema } : {} } }],
-    edges: [],
-    entryId: nid,
-    exitIds: [nid]
-  };
-}
-function expandHuman(s) {
-  const sid = s.id || uid("human");
-  const nid = nodeId(sid);
-  if (s.schema !== void 0 && s.schema !== null) {
-    if (typeof s.schema !== "object") {
-      throw new Error(
-        `Step "${sid}": schema must be a JSON Schema object, e.g. { "type": "object", "properties": { ... } }. Got ${typeof s.schema} (${JSON.stringify(s.schema)}).`
-      );
-    }
-    validateSchema(s.schema, sid);
-  }
-  const schema = s.schema && typeof s.schema === "object" ? s.schema : void 0;
-  return {
-    nodes: [{ id: nid, type: "human_feedback", name: sid, config: { title: s.title ?? sid }, input: { template: translate(s.prompt) }, output: { key: sid, ...schema ? { schema } : {} } }],
-    edges: [],
-    entryId: nid,
-    exitIds: [nid]
-  };
-}
-function expandCondition(s) {
-  const sid = s.id || uid("cond");
-  const nid = nodeId(sid);
-  if (s.branches) {
-    const branchExps = {};
-    for (const [key, steps] of Object.entries(s.branches)) {
-      branchExps[key] = expandSteps(Array.isArray(steps) ? steps : [steps]);
-    }
-    const allNodes = Object.values(branchExps).flatMap((e) => e.nodes);
-    const allEdges = Object.values(branchExps).flatMap((e) => e.edges);
-    const allExitIds = [...new Set(Object.values(branchExps).flatMap((e) => e.exitIds))];
-    const branchEntryIds = Object.fromEntries(
-      Object.entries(branchExps).map(([k, v]) => [k, v.entryId])
-    );
-    return {
-      nodes: allNodes,
-      edges: allEdges,
-      entryId: nid,
-      exitIds: allExitIds,
-      branchEntryIds
-    };
-  }
-  if (!s.then) {
-    throw new Error(`Condition step "${sid}": must have either "then" or "branches"`);
-  }
-  const thenSteps = Array.isArray(s.then) ? s.then : [s.then];
-  const elseSteps = s.else ? Array.isArray(s.else) ? s.else : [s.else] : [];
-  const thenExp = expandSteps(thenSteps);
-  const elseExp = expandSteps(elseSteps);
-  return {
-    nodes: [...thenExp.nodes, ...elseExp.nodes],
-    edges: [...thenExp.edges, ...elseExp.edges],
-    entryId: nid,
-    exitIds: [...thenExp.exitIds, ...elseExp.exitIds],
-    thenEntryId: thenExp.entryId,
-    elseEntryId: elseExp.entryId
-  };
-}
-function expandMap(s) {
-  const sid = s.id;
-  const nid = nodeId(sid);
-  const inner = s.each;
-  return {
-    nodes: [{
-      id: nid,
-      type: "map",
-      name: sid,
-      source: `state.${s.source}`,
-      itemKey: "item",
-      config: { batchSize: s.batch ?? 50, maxConcurrency: s.concurrency ?? 5, innerConcurrency: s.concurrency ?? 5 },
-      node: { type: "agent", input: inner.prompt ? { template: translate(inner.prompt) } : void 0, ...inner.schema && typeof inner.schema === "object" ? { schema: inner.schema } : {} },
-      ...s.reduce ? { reduce: { input: s.reduce.prompt ? { template: translate(s.reduce.prompt) } : void 0, ...s.reduce.schema && typeof s.reduce.schema === "object" ? { schema: s.reduce.schema } : {} } } : {},
-      output: { key: sid }
-    }],
-    edges: [],
-    entryId: nid,
-    exitIds: [nid]
-  };
-}
-function expandParallel(s) {
-  const nodes = [];
-  const edges = [];
-  const entryIds = [];
-  const exitIds = [];
-  for (const step of s.steps) {
-    const exp = expandStep(step);
-    nodes.push(...exp.nodes);
-    edges.push(...exp.edges);
-    entryIds.push(exp.entryId);
-    if (exp.exitIds.length > 0) exitIds.push(...exp.exitIds);
-  }
-  return { nodes, edges, entryId: entryIds[0], exitIds };
-}
-function expandEnd(s) {
-  const sid = uid("end");
-  const nid = nodeId(sid);
-  return { nodes: [{ id: nid, type: "terminal", name: sid, status: s.status ?? "success" }], edges: [], entryId: nid, exitIds: [] };
-}
-function expandSteps(steps, fromStart = false) {
-  if (steps.length === 0) return { nodes: [], edges: [], entryId: "END", exitIds: ["END"] };
-  const allNodes = [];
-  const allEdges = [];
-  let prevExitIds = [];
-  let firstEntryId = null;
-  for (let i = 0; i < steps.length; i++) {
-    const exp = expandStep(steps[i]);
-    if (exp.nodes.length > 0) allNodes.push(...exp.nodes);
-    if (exp.edges.length > 0) allEdges.push(...exp.edges);
-    if (firstEntryId === null) firstEntryId = exp.entryId;
-    if (prevExitIds.length > 0) addEdge(steps[i], exp, prevExitIds, allEdges);
-    else if (fromStart && i === 0) addEdge(steps[i], exp, ["START"], allEdges);
-    prevExitIds = exp.exitIds.length > 0 ? exp.exitIds : prevExitIds;
-  }
-  return { nodes: allNodes, edges: allEdges, entryId: firstEntryId || "END", exitIds: prevExitIds };
-}
-function toSafeStateExpr(expr) {
-  const match = expr.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)/);
-  if (!match) return `state.${expr}`;
-  const field = match[0];
-  const rest = expr.slice(field.length);
-  return `state["${field}"]${rest}`;
-}
-function addEdge(step, exp, fromIds, allEdges) {
-  if (step.type === "condition") {
-    const s = step;
-    if (s.if.includes("{{")) {
-      throw new Error(
-        `Condition step "${s.id || "unnamed"}": the \`if\` field contains "{{". Use a plain state field name or JavaScript expression (e.g. "intent", "score >= 60"). Template markers {{...}} are only for \`prompt\` fields, not \`if\`. Found: "${s.if}"`
-      );
-    }
-    if (s.branches) {
-      const condExp = exp;
-      const exprCode = toSafeStateExpr(s.if);
-      const mapping = {};
-      for (const [key, branchId] of Object.entries(condExp.branchEntryIds)) {
-        if (branchId) mapping[key] = branchId;
-      }
-      for (const fromId of fromIds) allEdges.push({ from: fromId, type: "conditional", rule: { type: "expression", code: exprCode, mapping } });
-    } else {
-      const condExp = exp;
-      const exprCode = `${toSafeStateExpr(s.if)} ? 'then' : 'else'`;
-      const mapping = {};
-      if (condExp.thenEntryId) mapping.then = condExp.thenEntryId;
-      if (condExp.elseEntryId) mapping.else = condExp.elseEntryId;
-      for (const fromId of fromIds) allEdges.push({ from: fromId, type: "conditional", rule: { type: "expression", code: exprCode, mapping } });
-    }
-  } else if (step.type === "parallel") {
-    for (const fromId of fromIds) {
-      for (const sub of step.steps) allEdges.push({ from: fromId, to: expandStep(sub).entryId });
-    }
-  } else {
-    for (const fromId of fromIds) allEdges.push({ from: fromId, to: exp.entryId });
-  }
-}
-function collectIds(steps) {
-  const ids = [];
-  function walk(s) {
-    const id = s.type === "condition" ? s.id || uid("cond") : s.type === "parallel" ? s.id || uid("par") : s.type === "end" ? uid("end") : s.id || s.id || uid("human");
-    if (s.type !== "end" && s.type !== "condition") ids.push(id);
-    if (s.type === "condition") {
-      const c = s;
-      if (c.branches) {
-        for (const steps2 of Object.values(c.branches)) {
-          (Array.isArray(steps2) ? steps2 : [steps2]).forEach(walk);
-        }
-      } else {
-        (Array.isArray(c.then) ? c.then : [c.then]).forEach(walk);
-        if (c.else) (Array.isArray(c.else) ? c.else : [c.else]).forEach(walk);
-      }
-    }
-    if (s.type === "parallel") s.steps.forEach(walk);
-  }
-  steps.forEach(walk);
-  return [...new Set(ids)];
-}
-function collectSourceIds(steps) {
-  const ids = [];
-  function walk(s) {
-    if (s.type === "map") ids.push(s.source);
-    if (s.type === "condition") {
-      const c = s;
-      if (c.branches) {
-        for (const steps2 of Object.values(c.branches)) {
-          (Array.isArray(steps2) ? steps2 : [steps2]).forEach(walk);
-        }
-      } else {
-        (Array.isArray(c.then) ? c.then : [c.then]).forEach(walk);
-        if (c.else) (Array.isArray(c.else) ? c.else : [c.else]).forEach(walk);
-      }
-    }
-    if (s.type === "parallel") s.steps.forEach(walk);
-  }
-  steps.forEach(walk);
-  return [...new Set(ids)];
-}
-function expand(dsl) {
-  _counter = 0;
-  console.log(`[WF EXPAND] expanding workflow "${dsl.name}" | stepCount=${dsl.steps.length}`);
-  const inputNode = {
-    id: "n_input",
-    type: "input",
-    name: "input",
-    output: { key: "input" }
-  };
-  const expanded = expandSteps(dsl.steps, true);
-  const edges = expanded.entryId === "END" ? [{ from: "START", to: "n_input" }] : [
-    ...expanded.edges.map((e) => ({ ...e, from: e.from === "START" ? "n_input" : e.from })),
-    { from: "START", to: "n_input" }
-  ];
-  const nodes = [inputNode, ...expanded.nodes];
-  const ids = collectIds(dsl.steps);
-  const sourceIds = collectSourceIds(dsl.steps);
-  const fields = { input: { type: "string" } };
-  for (const id of ids) fields[id] = inferFieldType(id);
-  for (const id of sourceIds) {
-    if (!fields[id]) fields[id] = inferFieldType(id);
-  }
-  const result = { version: "1.0", name: dsl.name, state: { fields }, nodes, edges };
-  console.log(`[WF EXPAND] done | nodeCount=${result.nodes.length} | nodeIds=[${result.nodes.map((n) => `${n.id}:${n.type}`).join(", ")}] | fieldIds=[${Object.keys(fields).join(", ")}]`);
-  return result;
-}
-
 // src/workflow/compile.ts
-function compileWorkflow(dsl, resolveAgent, checkpointer, trackingStore) {
-  console.log(`[WF COMPILE] compiling "${dsl.name}" | stepCount=${dsl.steps.length}`);
-  const ir = expand(dsl);
+function compileWorkflow(yamlStr, resolveAgent, checkpointer, trackingStore) {
+  console.log(`[WF COMPILE] compiling YAML workflow`);
+  const ir = parseYaml(yamlStr);
+  return compileInternal(ir, resolveAgent, checkpointer, trackingStore);
+}
+function compileInternal(ir, resolveAgent, checkpointer, trackingStore) {
   validateAndThrow(ir);
   console.log(`[WF COMPILE] validation passed`);
   const StateAnnotation = buildStateAnnotation(ir.state?.fields);
@@ -1133,21 +1063,13 @@ function compileWorkflow(dsl, resolveAgent, checkpointer, trackingStore) {
   }
   for (const edge of ir.edges) {
     const from = edge.from === "START" ? START : edge.from;
-    if (edge.type === "conditional") {
-      if (!edge.rule) {
-        throw new Error(`Conditional edge from "${edge.from}" has no rule`);
-      }
-      const router = buildRouter(edge.rule);
-      builder.addConditionalEdges(from, router, edge.rule.mapping);
-    } else {
-      const targets = Array.isArray(edge.to) ? edge.to : [edge.to];
-      for (const to of targets) {
-        builder.addEdge(from, to === "END" ? END : to);
-      }
+    const targets = Array.isArray(edge.to) ? edge.to : [edge.to];
+    for (const to of targets) {
+      builder.addEdge(from, to === "END" ? END : to);
     }
   }
   const graph = builder.compile({ checkpointer, name: ir.name });
-  console.log(`[WF COMPILE] graph compiled successfully, ready to run`);
+  console.log(`[WF COMPILE] graph compiled successfully`);
   return graph;
 }
 function validateDSL(dsl) {
@@ -1162,7 +1084,6 @@ function validateDSL(dsl) {
   const terminalIds = new Set(
     dsl.nodes.filter((n) => n.type === "terminal").map((n) => n.id)
   );
-  const declaredFields = new Set(Object.keys(dsl.state?.fields ?? {}));
   for (const edge of dsl.edges) {
     if (edge.from !== "START" && !nodeIds.has(edge.from)) {
       errors.push({ type: "error", message: `Edge from "${edge.from}" references unknown node` });
@@ -1176,24 +1097,12 @@ function validateDSL(dsl) {
         errors.push({ type: "error", message: `Edge to "${to}" references unknown node` });
       }
     }
-    if (edge.type === "conditional" && edge.rule) {
-      for (const targetId of Object.values(edge.rule.mapping)) {
-        if (targetId !== "END" && !nodeIds.has(targetId)) {
-          errors.push({ type: "error", message: `Conditional edge mapping references unknown node "${targetId}"` });
-        }
-      }
-      if (edge.rule.type === "state_field" && edge.rule.field) {
-        if (!declaredFields.has(edge.rule.field)) {
-          errors.push({ type: "warning", message: `Conditional edge reads "${edge.rule.field}" but it is not declared in state.fields` });
-        }
-      }
-    }
   }
   for (const node of dsl.nodes) {
     if (node.type === "terminal") {
       const hasIncoming = dsl.edges.some((e) => {
         const targets = Array.isArray(e.to) ? e.to : e.to ? [e.to] : [];
-        return targets.includes(node.id) || e.type === "conditional" && e.rule && Object.values(e.rule.mapping).includes(node.id);
+        return targets.includes(node.id);
       });
       if (!hasIncoming) {
         errors.push({ type: "warning", message: `Terminal node "${node.id}" has no incoming edge` });
@@ -1209,36 +1118,11 @@ function validateAndThrow(dsl) {
     throw new Error(critical.map((e) => e.message).join("; "));
   }
 }
-function buildRouter(rule) {
-  if (rule.type === "state_field") {
-    if (!rule.field) throw new Error("state_field rule requires a field name");
-    return (state) => {
-      const value = resolvePath(state, `state.${rule.field}`);
-      const key = String(value);
-      if (rule.mapping[key] !== void 0) return key;
-      if (rule.mapping["default"] !== void 0) return "default";
-      throw new Error(
-        `Conditional router produced key "${key}" (from field "${rule.field}"), but it is not in mapping: ${JSON.stringify(Object.keys(rule.mapping))}`
-      );
-    };
-  }
-  if (rule.type === "expression") {
-    if (!rule.code) throw new Error("expression rule requires code");
-    const fn = new Function("state", `return ${rule.code}`);
-    return (state) => {
-      const value = fn(state);
-      const key = String(value);
-      if (rule.mapping[key] !== void 0) return key;
-      if (rule.mapping["default"] !== void 0) return "default";
-      throw new Error(
-        `Conditional router produced key "${key}" (from expression "${rule.code}"), but it is not in mapping: ${JSON.stringify(Object.keys(rule.mapping))}`
-      );
-    };
-  }
-  throw new Error(`Unknown rule type: ${rule.type}`);
-}
 
 export {
+  toJsonSchema,
+  toSafeStateExpr,
+  parseYaml,
   buildStateAnnotation,
   resolvePath,
   renderTemplate,
@@ -1247,12 +1131,10 @@ export {
   parallelLimit,
   invokeWithRetry,
   createAgentNode,
-  createHumanFeedbackNode,
   createMapNode,
-  createTerminalNode,
   createNodeHandler,
-  expand,
   compileWorkflow,
+  compileInternal,
   validateDSL
 };
-//# sourceMappingURL=chunk-FN4TRQK4.mjs.map
+//# sourceMappingURL=chunk-SGRFQY3E.mjs.map