@axiom-lattice/core 2.1.78 → 2.1.80

package/dist/chunk-FN4TRQK4.mjs

@@ -0,0 +1,1258 @@
+// src/workflow/compile.ts
+import {
+  StateGraph,
+  START,
+  END
+} from "@langchain/langgraph";
+
+// src/workflow/utils.ts
+import {
+  Annotation
+} from "@langchain/langgraph";
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+function buildStateAnnotation(fields) {
+  const annotations = {};
+  if (fields) {
+    for (const [key, field] of Object.entries(fields)) {
+      annotations[key] = Annotation({
+        default: () => field.default ?? defaultValueForType(field.type),
+        reducer: buildReducer(field.reducer ?? "replace")
+      });
+    }
+  }
+  if (!annotations["messages"]) {
+    annotations["messages"] = Annotation({
+      default: () => [],
+      reducer: (prev, next) => [...prev, ...next]
+    });
+  }
+  annotations["phase"] = Annotation({
+    default: () => "init",
+    reducer: (_prev, next) => next
+  });
+  if (!annotations["status"]) {
+    annotations["status"] = Annotation({
+      default: () => "",
+      reducer: (_prev, next) => next
+    });
+  }
+  if (!annotations["_runId"]) {
+    annotations["_runId"] = Annotation({
+      default: () => void 0,
+      reducer: (_prev, next) => next ?? _prev
+    });
+  }
+  return Annotation.Root(annotations);
+}
+function defaultValueForType(type) {
+  switch (type) {
+    case "string":
+      return "";
+    case "number":
+      return null;
+    case "boolean":
+      return false;
+    case "object":
+      return null;
+    case "array":
+      return [];
+    default:
+      return null;
+  }
+}
+function buildReducer(kind) {
+  switch (kind) {
+    case "append":
+      return (prev, next) => {
+        const arr = Array.isArray(prev) ? prev : [];
+        return arr.concat(Array.isArray(next) ? next : [next]);
+      };
+    case "merge":
+      return (prev, next) => {
+        const obj = prev && typeof prev === "object" && !Array.isArray(prev) ? prev : {};
+        const merge = next && typeof next === "object" && !Array.isArray(next) ? next : {};
+        return { ...obj, ...merge };
+      };
+    case "replace":
+    default:
+      return (_prev, next) => next;
+  }
+}
+function resolvePath(obj, path) {
+  const cleanPath = path.startsWith("state.") ? path.slice(6) : path;
+  const parts = cleanPath.split(/\.|\[|\]\.?/).filter(Boolean);
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current === "object") {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function renderTemplate(template, state, item) {
+  return template.replace(/\$\{([^}]+)\}/g, (_match, expr) => {
+    const trimmed = expr.trim();
+    if (trimmed.startsWith("state.")) {
+      const val = resolvePath(state, trimmed);
+      return val === void 0 ? "" : formatValue(val);
+    }
+    if (trimmed.startsWith("item.") || trimmed === "item") {
+      if (!item) return "";
+      if (trimmed === "item") {
+        if (typeof item === "object" && "item" in item) {
+          return formatValue(item.item);
+        }
+        return formatValue(item);
+      }
+      const itemPath = trimmed;
+      const val = resolvePath({ item }, itemPath);
+      return val === void 0 ? "" : formatValue(val);
+    }
+    if (item && typeof item === "object") {
+      const firstSeg = trimmed.split(".")[0];
+      if (firstSeg in item) {
+        const val = resolvePath({ item }, `item.${trimmed}`);
+        return val === void 0 ? "" : formatValue(val);
+      }
+    }
+    return `\${${trimmed}}`;
+  });
+}
+function formatValue(val) {
+  if (typeof val === "string") return val;
+  if (val === null || val === void 0) return "";
+  if (Array.isArray(val)) {
+    const parts = val.map((item) => {
+      const content = item?.content ?? item?.kwargs?.content;
+      if (typeof content === "string") return content;
+      if (Array.isArray(content)) {
+        return content.filter((c) => c?.type === "text").map((c) => String(c.text ?? "")).join("\n");
+      }
+      if (content && typeof content === "object") return JSON.stringify(content, null, 2);
+      if (item && typeof item === "object") return JSON.stringify(item, null, 2);
+      return String(item);
+    });
+    const result = parts.filter(Boolean).join("\n");
+    return result || JSON.stringify(val, null, 2);
+  }
+  return JSON.stringify(val, null, 2);
+}
+function buildInput(input, state, item, outputSchema) {
+  let prompt = input?.template ? renderTemplate(input.template, state, item) : "";
+  if (outputSchema) {
+    const example = schemaToExample(outputSchema);
+    const schemaInstruction = `
+
+Output must be valid JSON in exactly this shape. Return ONLY the JSON, no other text or markdown:
+${example}`;
+    prompt = prompt + schemaInstruction;
+  }
+  return { messages: [new HumanMessage(prompt)] };
+}
+function schemaToExample(schema) {
+  const example = schemaValueToExample(schema);
+  return JSON.stringify(example, null, 2);
+}
+function schemaValueToExample(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value !== "object") return value;
+  const obj = value;
+  if (obj.type === "string") return "<string>";
+  if (obj.type === "number") return "<number>";
+  if (obj.type === "boolean") return "<boolean>";
+  if (obj.type === "integer") return "<integer>";
+  if (obj.type === "array" && obj.items) {
+    return [schemaValueToExample(obj.items)];
+  }
+  if (obj.type === "object" && obj.properties && typeof obj.properties === "object") {
+    const example2 = {};
+    for (const [k, v] of Object.entries(obj.properties)) {
+      example2[k] = schemaValueToExample(v);
+    }
+    return example2;
+  }
+  if (obj.type === "object") return {};
+  if (Array.isArray(value)) {
+    if (value.length === 1) {
+      return [schemaValueToExample(value[0])];
+    }
+    return value.map(schemaValueToExample);
+  }
+  const example = {};
+  for (const [k, v] of Object.entries(obj)) {
+    example[k] = schemaValueToExample(v);
+  }
+  return example;
+}
+function extractOutput(result) {
+  if ("structuredResponse" in result && result.structuredResponse !== void 0) {
+    return result.structuredResponse;
+  }
+  const messages = result.messages;
+  if (messages && Array.isArray(messages)) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      if (msg._getType() === "ai") {
+        const content = msg.content;
+        if (typeof content === "object" && content !== null && !Array.isArray(content)) {
+          return content;
+        }
+        if (Array.isArray(content)) {
+          const textParts = content.filter(
+            (c) => typeof c === "object" && c !== null && c.type === "text"
+          ).map((c) => c.text).join("\n");
+          if (textParts) {
+            try {
+              return JSON.parse(textParts);
+            } catch {
+              const fenced = extractJsonFromFence(textParts);
+              if (fenced !== void 0) return fenced;
+              return textParts;
+            }
+          }
+          return content;
+        }
+        if (typeof content === "string") {
+          try {
+            return JSON.parse(content);
+          } catch {
+            const fenced = extractJsonFromFence(content);
+            if (fenced !== void 0) return fenced;
+            return content;
+          }
+        }
+        return content;
+      }
+    }
+  }
+  const { messages: _msgs, ...rest } = result;
+  void _msgs;
+  return rest;
+}
+function extractJsonFromFence(text) {
+  const jsonFence = text.match(/```json\s*\n([\s\S]*?)```/);
+  if (jsonFence) {
+    try {
+      return JSON.parse(jsonFence[1].trim());
+    } catch {
+    }
+  }
+  const plainFence = text.match(/```\s*\n([\s\S]*?)```/);
+  if (plainFence) {
+    try {
+      return JSON.parse(plainFence[1].trim());
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function parallelLimit(items, limit, fn) {
+  const results = new Array(items.length);
+  let index = 0;
+  async function worker() {
+    while (index < items.length) {
+      const i = index++;
+      results[i] = await fn(items[i], i);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+  return results;
+}
+async function invokeWithRetry(fn, maxRetries, retryOn, timeoutMs) {
+  let lastError;
+  for (let i = 0; i <= maxRetries; i++) {
+    try {
+      const promise = fn();
+      if (timeoutMs && timeoutMs > 0) {
+        return await withTimeout(promise, timeoutMs);
+      }
+      return await promise;
+    } catch (err) {
+      if (err?.name === "GraphInterrupt") {
+        throw err;
+      }
+      lastError = err;
+      if (i === maxRetries) throw err;
+      if (retryOn?.length) {
+        const errName = err?.name ?? "";
+        if (!retryOn.includes(errName)) throw err;
+      }
+    }
+  }
+  throw lastError;
+}
+function withTimeout(promise, ms) {
+  return Promise.race([
+    promise,
+    new Promise(
+      (_, reject) => setTimeout(() => reject(new Error(`Operation timed out after ${ms}ms`)), ms)
+    )
+  ]);
+}
+function createAgentNode(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}] 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);
+      console.log(`[WF][${node.id}] agent resolved, building input...`);
+      const input = buildInput(
+        node.input,
+        state,
+        void 0,
+        responseFormat ? void 0 : node.output?.schema
+      );
+      const renderedInput = input.messages[0]?.content ?? "";
+      console.log(`[WF][${node.id}] === INPUT (full) ===
+${renderedInput}
+=== END INPUT ===`);
+      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}`
+        }
+      };
+      let result;
+      try {
+        console.log(`[WF][${node.id}] invoking agent.invoke()...`);
+        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...`);
+      } 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;
+        }
+        const errMsg = err?.message ?? "";
+        console.log(`[WF][${node.id}] invoke FAILED: ${errMsg}`);
+        if (responseFormat && (errMsg.includes("tool_choice") || errMsg.includes("thinking") || errMsg.includes("reasoning") || errMsg.includes("InvalidParameter"))) {
+          console.log(`[WF][${node.id}] attempting fallback (text-based schema injection)...`);
+          const fallbackClient = await resolveAgent(node.ref, void 0, node.type);
+          const fallbackInput = buildInput(node.input, state, void 0, responseFormat);
+          result = await invokeWithRetry(
+            () => fallbackClient.invoke(fallbackInput, subConfig),
+            node.config?.maxRetries ?? 0,
+            node.config?.retryOn,
+            node.config?.timeout
+          );
+          console.log(`[WF][${node.id}] fallback invoke SUCCESS`);
+        } else {
+          throw err;
+        }
+      }
+      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;
+      }
+      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") {
+        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);
+          });
+        }
+        trackingStore.updateWorkflowRun(runId, {
+          status: "failed",
+          errorMessage: err.message,
+          completedAt: /* @__PURE__ */ new Date()
+        }).catch((e) => {
+          console.warn("Failed to finalize WorkflowRun:", e.message);
+        });
+      }
+      throw err;
+    }
+  };
+}
+function createHumanFeedbackNode(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);
+          });
+        }
+        trackingStore.updateWorkflowRun(runId, {
+          status: "failed",
+          errorMessage: err.message,
+          completedAt: /* @__PURE__ */ new Date()
+        }).catch((e) => {
+          console.warn("Failed to finalize WorkflowRun:", e.message);
+        });
+      }
+      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) {
+      trackingStore.updateWorkflowRun(runId, {
+        status: "running",
+        completedAt: null
+      }).catch(() => {
+      });
+    }
+    try {
+      const items = resolvePath(state, node.source);
+      if (trackingStore && runId) {
+        const step = await trackingStore.upsertRunStep({
+          runId,
+          tenantId,
+          stepType: node.type,
+          stepName: node.name,
+          input: { source: node.source, itemCount: Array.isArray(items) ? items.length : 0 }
+        }).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(() => {
+          });
+        }
+      }
+      if (!Array.isArray(items)) {
+        throw new Error(
+          `Map source "${node.source}" resolved to ${typeof items}, expected array`
+        );
+      }
+      const batchSize = node.config?.batchSize ?? 50;
+      const maxConcurrency = node.config?.maxConcurrency ?? 10;
+      const innerConcurrency = node.config?.innerConcurrency ?? 5;
+      const itemKey = node.itemKey ?? "item";
+      const innerClient = await resolveAgent(node.node.ref, node.node.schema, node.type);
+      const batches = chunk(items, batchSize);
+      const batchResults = await parallelLimit(batches, maxConcurrency, async (batch) => {
+        const itemResults = await parallelLimit(batch, innerConcurrency, async (item, itemIdx) => {
+          const itemCtx = { [itemKey]: item };
+          const input = buildInput(node.node.input, state, itemCtx);
+          const subConfig = {
+            ...config,
+            configurable: {
+              ...config?.configurable ?? {},
+              thread_id: `${config?.configurable?.thread_id ?? "default"}:${node.id}:item:${itemIdx}`
+            }
+          };
+          const result = await invokeWithRetry(
+            () => innerClient.invoke(input, subConfig),
+            node.config?.maxRetries ?? 0,
+            node.config?.retryOn,
+            node.config?.timeout
+          );
+          return extractOutput(result);
+        });
+        return itemResults;
+      });
+      const allResults = batchResults.flat();
+      let finalOutput = allResults;
+      if (node.reduce) {
+        const reduceClient = await resolveAgent(node.reduce.ref, node.reduce.schema, node.type);
+        const tempResultsKey = node.output?.key ?? `${node.id}_results`;
+        const tempState = { ...state, [tempResultsKey]: allResults };
+        const reduceInput = buildInput(node.reduce.input, tempState);
+        const reduceResult = await invokeWithRetry(
+          () => reduceClient.invoke(reduceInput, {
+            ...config,
+            configurable: {
+              ...config?.configurable ?? {},
+              thread_id: `${config?.configurable?.thread_id ?? "default"}:${node.id}:reduce`
+            }
+          }),
+          node.config?.maxRetries ?? 0,
+          node.config?.retryOn,
+          node.config?.timeout
+        );
+        finalOutput = extractOutput(reduceResult);
+      }
+      const update = { phase: node.id };
+      if (node.output?.key) {
+        update[node.output.key] = finalOutput;
+      }
+      if (trackingStore && runId && stepId) {
+        trackingStore.updateRunStep(runId, stepId, {
+          status: "completed",
+          output: finalOutput,
+          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;
+      }
+      console.error(`[WF][${node.id}] FAILED after ${Date.now() - startedAt}ms:`, err.stack || err.message);
+      if (trackingStore && runId) {
+        if (stepId) {
+          trackingStore.updateRunStep(runId, stepId, {
+            status: "failed",
+            errorMessage: err.message,
+            completedAt: /* @__PURE__ */ new Date(),
+            durationMs: Date.now() - startedAt
+          }).catch(() => {
+          });
+        }
+        trackingStore.updateWorkflowRun(runId, {
+          status: "failed",
+          errorMessage: err.message,
+          completedAt: /* @__PURE__ */ new Date()
+        }).catch(() => {
+        });
+      }
+      throw err;
+    }
+  };
+}
+function createInputNode(node, trackingStore) {
+  return async (state, config) => {
+    const tenantId = config?.configurable?.tenantId ?? "default";
+    const threadId = config?.configurable?.thread_id ?? "default";
+    const assistantId = config?.configurable?.assistantId || config?.configurable?.assistant_id || "unknown";
+    const messages = state.messages;
+    const humanMsg = messages?.find((m) => m._getType() === "human");
+    const inputText = typeof humanMsg?.content === "string" ? humanMsg.content : JSON.stringify(humanMsg?.content ?? "");
+    console.log(`[WF][n_input] input captured: "${inputText.slice(0, 200)}"`);
+    const update = { phase: node.id };
+    if (node.output?.key) update[node.output.key] = inputText;
+    if (trackingStore && !state._runId) {
+      try {
+        const run = await trackingStore.createWorkflowRun({
+          tenantId,
+          assistantId,
+          threadId,
+          topologyEdges: [],
+          metadata: { workflowName: node.name }
+        });
+        update._runId = run.id;
+        await trackingStore.createRunStep({
+          runId: run.id,
+          tenantId,
+          stepType: node.type,
+          stepName: node.name,
+          input: { rendered: inputText }
+        }).catch((e) => {
+          console.warn("Failed to create input run step:", e.message);
+        });
+      } catch (e) {
+        console.warn("Failed to create workflow run:", e.message);
+      }
+    }
+    return update;
+  };
+}
+function terminalStatusToRunStatus(status) {
+  switch (status) {
+    case "failed":
+      return "failed";
+    case "cancelled":
+      return "cancelled";
+    case "success":
+    default:
+      return "completed";
+  }
+}
+function createTerminalNode(node, trackingStore) {
+  const runStatus = terminalStatusToRunStatus(node.status);
+  return async (state) => {
+    const runId = state._runId;
+    if (trackingStore && runId) {
+      try {
+        await trackingStore.updateWorkflowRun(runId, {
+          status: runStatus,
+          completedAt: /* @__PURE__ */ new Date()
+        });
+      } catch (e) {
+        console.warn(`[WF][terminal] Failed to finalize WorkflowRun "${runId}":`, e.message);
+      }
+      try {
+        await trackingStore.createRunStep({
+          runId,
+          tenantId: state._tenantId ?? "default",
+          stepType: "terminal",
+          stepName: node.name,
+          input: { status: node.status }
+        });
+      } catch (e) {
+        console.warn(`[WF][terminal] Failed to create terminal RunStep:`, e.message);
+      }
+    }
+    return {
+      status: node.status,
+      phase: node.id
+    };
+  };
+}
+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":
+      return createTerminalNode(node, trackingStore);
+    case "input":
+      return createInputNode(node, trackingStore);
+    default:
+      throw new Error(`Unknown node type: ${node.type}`);
+  }
+}
+function chunk(arr, size) {
+  const result = [];
+  for (let i = 0; i < arr.length; i += size) {
+    result.push(arr.slice(i, i + 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);
+  validateAndThrow(ir);
+  console.log(`[WF COMPILE] validation passed`);
+  const StateAnnotation = buildStateAnnotation(ir.state?.fields);
+  const builder = new StateGraph(StateAnnotation);
+  for (const node of ir.nodes) {
+    console.log(`[WF COMPILE] registering node: id=${node.id} type=${node.type} name=${node.name}`);
+    const handler = createNodeHandler(node, resolveAgent, trackingStore);
+    builder.addNode(node.id, handler);
+  }
+  for (const node of ir.nodes) {
+    if (node.type === "terminal") {
+      builder.addEdge(node.id, END);
+    }
+  }
+  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 graph = builder.compile({ checkpointer, name: ir.name });
+  console.log(`[WF COMPILE] graph compiled successfully, ready to run`);
+  return graph;
+}
+function validateDSL(dsl) {
+  const errors = [];
+  const nodeIds = /* @__PURE__ */ new Set();
+  for (const node of dsl.nodes) {
+    if (nodeIds.has(node.id)) {
+      errors.push({ type: "error", message: `Duplicate node id "${node.id}"` });
+    }
+    nodeIds.add(node.id);
+  }
+  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` });
+    }
+    if (edge.from !== "START" && terminalIds.has(edge.from)) {
+      errors.push({ type: "error", message: `Terminal node "${edge.from}" cannot have outgoing edges` });
+    }
+    const targets = Array.isArray(edge.to) ? edge.to : edge.to ? [edge.to] : [];
+    for (const to of targets) {
+      if (to !== "END" && !nodeIds.has(to)) {
+        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);
+      });
+      if (!hasIncoming) {
+        errors.push({ type: "warning", message: `Terminal node "${node.id}" has no incoming edge` });
+      }
+    }
+  }
+  return errors;
+}
+function validateAndThrow(dsl) {
+  const errors = validateDSL(dsl);
+  const critical = errors.filter((e) => e.type === "error");
+  if (critical.length > 0) {
+    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 {
+  buildStateAnnotation,
+  resolvePath,
+  renderTemplate,
+  buildInput,
+  extractOutput,
+  parallelLimit,
+  invokeWithRetry,
+  createAgentNode,
+  createHumanFeedbackNode,
+  createMapNode,
+  createTerminalNode,
+  createNodeHandler,
+  expand,
+  compileWorkflow,
+  validateDSL
+};
+//# sourceMappingURL=chunk-FN4TRQK4.mjs.map