@q1k-oss/behaviour-tree-workflows 0.0.4 → 0.0.6

package/dist/index.js

@@ -1045,6 +1045,21 @@ var Conditional = class extends CompositeNode {
 };
 
 // src/composites/for-each.ts
+function resolveFromBlackboard(blackboard, path2) {
+  const parts = path2.split(".");
+  const firstPart = parts[0];
+  if (!firstPart) return void 0;
+  let value = blackboard.get(firstPart);
+  for (let i = 1; i < parts.length && value != null; i++) {
+    const part = parts[i];
+    if (part && typeof value === "object") {
+      value = value[part];
+    } else {
+      return void 0;
+    }
+  }
+  return value;
+}
 var ForEach = class extends CompositeNode {
   collectionKey;
   itemKey;
@@ -1068,7 +1083,7 @@ var ForEach = class extends CompositeNode {
         "ForEach requires at least one child (body)"
       );
     }
-    const collection = context.blackboard.get(this.collectionKey);
+    const collection = this.collectionKey.includes(".") ? resolveFromBlackboard(context.blackboard, this.collectionKey) : context.blackboard.get(this.collectionKey);
     if (!collection) {
       this.log(`Collection '${this.collectionKey}' not found in blackboard`);
       this._status = "FAILURE" /* FAILURE */;
@@ -2548,74 +2563,153 @@ var setVariableSchema = createNodeSchema("SetVariable", {
   value: z6.unknown()
 });
 
-// src/actions/llm-tool-call.schema.ts
+// src/utilities/math-op.schema.ts
 import { z as z7 } from "zod";
-var toolDefinitionSchema = z7.object({
-  name: z7.string().min(1),
-  description: z7.string().min(1),
-  inputSchema: z7.record(z7.string(), z7.unknown())
+var mathOpSchema = createNodeSchema("MathOp", {
+  expression: z7.string().min(1, "expression is required"),
+  outputKey: z7.string().min(1, "outputKey is required"),
+  round: z7.enum(["none", "round", "floor", "ceil"]).optional(),
+  precision: z7.number().int().nonnegative().optional()
+});
+
+// src/utilities/array-filter.schema.ts
+import { z as z8 } from "zod";
+var filterConditionSchema = z8.object({
+  field: z8.string().min(1),
+  operator: z8.enum([
+    "eq",
+    "ne",
+    "gt",
+    "lt",
+    "gte",
+    "lte",
+    "in",
+    "nin",
+    "exists",
+    "regex",
+    "between",
+    "contains"
+  ]),
+  value: z8.unknown().optional(),
+  range: z8.tuple([z8.unknown(), z8.unknown()]).optional()
+});
+var arrayFilterSchema = createNodeSchema("ArrayFilter", {
+  input: z8.string().min(1, "input is required"),
+  outputKey: z8.string().min(1, "outputKey is required"),
+  conditions: z8.array(filterConditionSchema).min(1, "at least one condition is required"),
+  logic: z8.enum(["and", "or"]).optional()
+});
+
+// src/utilities/aggregate.schema.ts
+import { z as z9 } from "zod";
+var aggregateOperationSchema = z9.object({
+  type: z9.enum(["count", "sum", "avg", "min", "max"]),
+  field: z9.string().optional(),
+  as: z9.string().optional()
+});
+var aggregateSchema = createNodeSchema("Aggregate", {
+  input: z9.string().min(1, "input is required"),
+  outputKey: z9.string().min(1, "outputKey is required"),
+  operations: z9.array(aggregateOperationSchema).min(1, "at least one operation is required"),
+  groupBy: z9.string().optional()
+});
+
+// src/utilities/threshold-check.schema.ts
+import { z as z10 } from "zod";
+var thresholdLevelSchema = z10.object({
+  operator: z10.enum(["lte", "lt", "gte", "gt", "eq", "ne", "between"]),
+  value: z10.unknown().optional(),
+  range: z10.tuple([z10.unknown(), z10.unknown()]).optional(),
+  label: z10.string().min(1, "label is required")
+});
+var thresholdCheckSchema = createNodeSchema("ThresholdCheck", {
+  value: z10.unknown(),
+  thresholds: z10.array(thresholdLevelSchema).min(1, "at least one threshold is required"),
+  outputKey: z10.string().optional(),
+  failOn: z10.array(z10.string()).optional()
+});
+
+// src/utilities/data-transform.schema.ts
+import { z as z11 } from "zod";
+var transformMappingSchema = z11.object({
+  target: z11.string().min(1, "target is required"),
+  value: z11.unknown(),
+  coerce: z11.enum(["string", "number", "boolean"]).optional()
+});
+var dataTransformSchema = createNodeSchema("DataTransform", {
+  outputKey: z11.string().min(1, "outputKey is required"),
+  mappings: z11.array(transformMappingSchema).min(1, "at least one mapping is required"),
+  wrapInArray: z11.boolean().optional()
+});
+
+// src/actions/llm-tool-call.schema.ts
+import { z as z12 } from "zod";
+var toolDefinitionSchema = z12.object({
+  name: z12.string().min(1),
+  description: z12.string().min(1),
+  inputSchema: z12.record(z12.string(), z12.unknown())
 });
 var llmToolCallSchema = createNodeSchema("LLMToolCall", {
-  provider: z7.enum(["anthropic", "openai", "google", "ollama"]),
-  model: z7.string().min(1, "Model is required"),
-  systemPrompt: z7.string().optional(),
-  messagesKey: z7.string().min(1, "messagesKey is required"),
-  userMessageKey: z7.string().optional(),
-  toolsKey: z7.string().optional(),
-  tools: z7.array(toolDefinitionSchema).optional(),
-  temperature: z7.number().min(0).max(2).optional(),
-  maxTokens: z7.number().int().positive().optional(),
-  outputKey: z7.string().min(1, "outputKey is required")
+  provider: z12.enum(["anthropic", "openai", "google", "ollama"]),
+  model: z12.string().min(1, "Model is required"),
+  systemPrompt: z12.string().optional(),
+  messagesKey: z12.string().min(1, "messagesKey is required"),
+  userMessageKey: z12.string().optional(),
+  toolsKey: z12.string().optional(),
+  tools: z12.array(toolDefinitionSchema).optional(),
+  temperature: z12.number().min(0).max(2).optional(),
+  maxTokens: z12.number().int().positive().optional(),
+  outputKey: z12.string().min(1, "outputKey is required")
 });
 
 // src/actions/tool-executor.schema.ts
-import { z as z8 } from "zod";
+import { z as z13 } from "zod";
 var toolExecutorSchema = createNodeSchema("ToolExecutor", {
-  responseKey: z8.string().min(1, "responseKey is required"),
-  messagesKey: z8.string().min(1, "messagesKey is required"),
-  outputKey: z8.string().optional()
+  responseKey: z13.string().min(1, "responseKey is required"),
+  messagesKey: z13.string().min(1, "messagesKey is required"),
+  outputKey: z13.string().optional()
 });
 
 // src/actions/wait-for-signal.schema.ts
-import { z as z9 } from "zod";
+import { z as z14 } from "zod";
 var waitForSignalSchema = createNodeSchema("WaitForSignal", {
-  signalName: z9.string().min(1, "signalName is required"),
-  signalKey: z9.string().optional(),
-  timeoutMs: z9.number().int().positive().optional().default(864e5),
-  outputKey: z9.string().min(1, "outputKey is required")
+  signalName: z14.string().min(1, "signalName is required"),
+  signalKey: z14.string().optional(),
+  timeoutMs: z14.number().int().positive().optional().default(864e5),
+  outputKey: z14.string().min(1, "outputKey is required")
 });
 
 // src/actions/tool-router.schema.ts
-import { z as z10 } from "zod";
-var toolDefinitionSchema2 = z10.object({
-  name: z10.string().min(1),
-  description: z10.string().min(1),
-  inputSchema: z10.record(z10.string(), z10.unknown())
+import { z as z15 } from "zod";
+var toolDefinitionSchema2 = z15.object({
+  name: z15.string().min(1),
+  description: z15.string().min(1),
+  inputSchema: z15.record(z15.string(), z15.unknown())
 });
-var ruleSchema = z10.object({
-  pattern: z10.string().min(1),
-  toolSets: z10.array(z10.string().min(1)).min(1)
+var ruleSchema = z15.object({
+  pattern: z15.string().min(1),
+  toolSets: z15.array(z15.string().min(1)).min(1)
 });
 var toolRouterSchema = createNodeSchema("ToolRouter", {
-  intentKey: z10.string().min(1, "intentKey is required"),
-  toolSets: z10.record(z10.string(), z10.array(toolDefinitionSchema2)),
-  defaultTools: z10.array(z10.string()).optional(),
-  rules: z10.array(ruleSchema).optional(),
-  outputKey: z10.string().min(1, "outputKey is required")
+  intentKey: z15.string().min(1, "intentKey is required"),
+  toolSets: z15.record(z15.string(), z15.array(toolDefinitionSchema2)),
+  defaultTools: z15.array(z15.string()).optional(),
+  rules: z15.array(ruleSchema).optional(),
+  outputKey: z15.string().min(1, "outputKey is required")
 });
 
 // src/decorators/streaming-sink.schema.ts
-import { z as z11 } from "zod";
+import { z as z16 } from "zod";
 var streamingSinkSchema = createNodeSchema("StreamingSink", {
-  channelId: z11.string().optional(),
-  channelKey: z11.string().optional()
+  channelId: z16.string().optional(),
+  channelKey: z16.string().optional()
 }).refine(
   (data) => data.channelId || data.channelKey,
   { message: "Either channelId or channelKey must be provided" }
 );
 
 // src/schemas/validation.ts
-import { z as z12 } from "zod";
+import { z as z17 } from "zod";
 function zodErrorToConfigurationError(error, nodeType, nodeId) {
   const nodeIdentifier = nodeId ? `${nodeType}:${nodeId}` : nodeType;
   const issues = error.issues.map((issue) => {
@@ -2631,7 +2725,7 @@ function validateConfiguration(schema, config, nodeType, nodeId) {
   try {
     return schema.parse(config);
   } catch (error) {
-    if (error instanceof z12.ZodError) {
+    if (error instanceof z17.ZodError) {
       throw zodErrorToConfigurationError(error, nodeType, nodeId);
     }
     throw error;
@@ -2650,14 +2744,14 @@ function safeValidateConfiguration(schema, config, nodeType, nodeId) {
 }
 
 // src/schemas/tree-definition.schema.ts
-import { z as z13 } from "zod";
-var treeDefSchemaObject = z13.object({
-  type: z13.string().min(1, "Node type is required"),
-  id: z13.string().optional(),
-  name: z13.string().optional(),
-  props: z13.record(z13.string(), z13.unknown()).optional(),
-  children: z13.array(
-    z13.lazy(() => treeDefinitionSchema)
+import { z as z18 } from "zod";
+var treeDefSchemaObject = z18.object({
+  type: z18.string().min(1, "Node type is required"),
+  id: z18.string().optional(),
+  name: z18.string().optional(),
+  props: z18.record(z18.string(), z18.unknown()).optional(),
+  children: z18.array(
+    z18.lazy(() => treeDefinitionSchema)
   ).optional()
 });
 var treeDefinitionSchema = treeDefSchemaObject;
@@ -2740,6 +2834,11 @@ var SchemaRegistry = class {
     this.register("BrowserAgent", browserAgentSchema);
     this.register("HumanTask", humanTaskSchema);
     this.register("SetVariable", setVariableSchema);
+    this.register("MathOp", mathOpSchema);
+    this.register("ArrayFilter", arrayFilterSchema);
+    this.register("Aggregate", aggregateSchema);
+    this.register("ThresholdCheck", thresholdCheckSchema);
+    this.register("DataTransform", dataTransformSchema);
     this.register("LLMToolCall", llmToolCallSchema);
     this.register("ToolExecutor", toolExecutorSchema);
     this.register("WaitForSignal", waitForSignalSchema);
@@ -3460,6 +3559,547 @@ var SetVariable = class extends ActionNode {
   }
 };
 
+// src/utilities/math-op.ts
+function tokenize(expr) {
+  const tokens = [];
+  let i = 0;
+  while (i < expr.length) {
+    const ch = expr[i];
+    if (ch === " " || ch === "	") {
+      i++;
+      continue;
+    }
+    if (ch === "(" || ch === ")") {
+      tokens.push({ type: ch === "(" ? "lparen" : "rparen", value: ch });
+      i++;
+      continue;
+    }
+    if (ch === "+" || ch === "-" || ch === "*" || ch === "/" || ch === "%") {
+      const prev = tokens.length > 0 ? tokens[tokens.length - 1] : void 0;
+      const isUnary = ch === "-" && (tokens.length === 0 || prev?.type === "op" || prev?.type === "lparen");
+      if (isUnary) {
+        let numStr = "-";
+        i++;
+        while (i < expr.length && isDigitOrDot(expr[i])) {
+          numStr += expr[i];
+          i++;
+        }
+        if (numStr === "-") {
+          tokens.push({ type: "number", value: -1 });
+          tokens.push({ type: "op", value: "*" });
+        } else {
+          const num = parseFloat(numStr);
+          if (isNaN(num)) throw new Error(`Invalid number: ${numStr}`);
+          tokens.push({ type: "number", value: num });
+        }
+        continue;
+      }
+      tokens.push({ type: "op", value: ch });
+      i++;
+      continue;
+    }
+    if (isDigitOrDot(ch)) {
+      let numStr = "";
+      while (i < expr.length && isDigitOrDot(expr[i])) {
+        numStr += expr[i];
+        i++;
+      }
+      const num = parseFloat(numStr);
+      if (isNaN(num)) throw new Error(`Invalid number: ${numStr}`);
+      tokens.push({ type: "number", value: num });
+      continue;
+    }
+    throw new Error(`Unexpected character: '${ch}' at position ${i}`);
+  }
+  return tokens;
+}
+function isDigitOrDot(ch) {
+  return ch >= "0" && ch <= "9" || ch === ".";
+}
+function evaluate(tokens) {
+  let pos = 0;
+  function current() {
+    return tokens[pos];
+  }
+  function parseExpr() {
+    let left = parseTerm();
+    let tok = current();
+    while (tok && tok.type === "op" && (tok.value === "+" || tok.value === "-")) {
+      const op = tok.value;
+      pos++;
+      const right = parseTerm();
+      left = op === "+" ? left + right : left - right;
+      tok = current();
+    }
+    return left;
+  }
+  function parseTerm() {
+    let left = parseFactor();
+    let tok = current();
+    while (tok && tok.type === "op" && (tok.value === "*" || tok.value === "/" || tok.value === "%")) {
+      const op = tok.value;
+      pos++;
+      const right = parseFactor();
+      if ((op === "/" || op === "%") && right === 0) {
+        throw new Error("Division by zero");
+      }
+      if (op === "*") left = left * right;
+      else if (op === "/") left = left / right;
+      else left = left % right;
+      tok = current();
+    }
+    return left;
+  }
+  function parseFactor() {
+    const tok = current();
+    if (!tok) {
+      throw new Error("Unexpected end of expression");
+    }
+    if (tok.type === "number") {
+      pos++;
+      return tok.value;
+    }
+    if (tok.type === "lparen") {
+      pos++;
+      const val = parseExpr();
+      const closing = current();
+      if (!closing || closing.type !== "rparen") {
+        throw new Error("Missing closing parenthesis");
+      }
+      pos++;
+      return val;
+    }
+    throw new Error(`Unexpected token: ${JSON.stringify(tok)}`);
+  }
+  const result = parseExpr();
+  const remaining = current();
+  if (remaining) {
+    throw new Error(`Unexpected token after expression: ${JSON.stringify(remaining)}`);
+  }
+  return result;
+}
+function safeEvaluate(expression) {
+  const tokens = tokenize(expression);
+  if (tokens.length === 0) {
+    throw new Error("Empty expression");
+  }
+  return evaluate(tokens);
+}
+function applyRounding(value, round, precision) {
+  if (round === "none") return value;
+  const factor = Math.pow(10, precision);
+  const scaled = value * factor;
+  switch (round) {
+    case "round":
+      return Math.round(scaled) / factor;
+    case "floor":
+      return Math.floor(scaled) / factor;
+    case "ceil":
+      return Math.ceil(scaled) / factor;
+    default:
+      return value;
+  }
+}
+var MathOp = class extends ActionNode {
+  expression;
+  outputKey;
+  round;
+  precision;
+  constructor(config) {
+    super(config);
+    this.expression = config.expression;
+    this.outputKey = config.outputKey;
+    this.round = config.round ?? "none";
+    this.precision = config.precision ?? 0;
+  }
+  async executeTick(context) {
+    try {
+      const varCtx = {
+        blackboard: context.blackboard,
+        input: context.input,
+        testData: context.testData
+      };
+      const resolved = resolveString(this.expression, varCtx);
+      let result;
+      if (typeof resolved === "number") {
+        result = resolved;
+      } else if (typeof resolved === "string") {
+        result = safeEvaluate(resolved);
+      } else {
+        throw new Error(`Expression resolved to non-numeric type: ${typeof resolved}`);
+      }
+      if (!isFinite(result)) {
+        throw new Error(`Expression result is not finite: ${result}`);
+      }
+      result = applyRounding(result, this.round, this.precision);
+      context.blackboard.set(this.outputKey, result);
+      this.log(`${this.expression} = ${result}`);
+      return "SUCCESS" /* SUCCESS */;
+    } catch (error) {
+      this._lastError = error instanceof Error ? error.message : String(error);
+      this.log(`MathOp failed: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+  }
+};
+
+// src/utilities/array-filter.ts
+function getFieldValue(item, path2) {
+  if (item === null || item === void 0) return void 0;
+  const parts = path2.split(".");
+  let current = item;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function evaluateCondition(item, condition, resolvedValue, resolvedRange) {
+  const fieldVal = getFieldValue(item, condition.field);
+  switch (condition.operator) {
+    case "eq":
+      return fieldVal === resolvedValue;
+    case "ne":
+      return fieldVal !== resolvedValue;
+    case "gt":
+      return fieldVal > resolvedValue;
+    case "lt":
+      return fieldVal < resolvedValue;
+    case "gte":
+      return fieldVal >= resolvedValue;
+    case "lte":
+      return fieldVal <= resolvedValue;
+    case "in":
+      if (!Array.isArray(resolvedValue)) return false;
+      return resolvedValue.includes(fieldVal);
+    case "nin":
+      if (!Array.isArray(resolvedValue)) return true;
+      return !resolvedValue.includes(fieldVal);
+    case "exists":
+      const shouldExist = resolvedValue !== false;
+      const exists = fieldVal !== null && fieldVal !== void 0;
+      return shouldExist ? exists : !exists;
+    case "regex": {
+      if (typeof fieldVal !== "string" || typeof resolvedValue !== "string") return false;
+      try {
+        return new RegExp(resolvedValue).test(fieldVal);
+      } catch {
+        return false;
+      }
+    }
+    case "between": {
+      if (!resolvedRange) return false;
+      const [min, max] = resolvedRange;
+      return fieldVal >= min && fieldVal <= max;
+    }
+    case "contains": {
+      if (typeof fieldVal === "string" && typeof resolvedValue === "string") {
+        return fieldVal.includes(resolvedValue);
+      }
+      if (Array.isArray(fieldVal)) {
+        return fieldVal.includes(resolvedValue);
+      }
+      return false;
+    }
+    default:
+      return false;
+  }
+}
+var ArrayFilter = class extends ActionNode {
+  input;
+  outputKey;
+  conditions;
+  logic;
+  constructor(config) {
+    super(config);
+    this.input = config.input;
+    this.outputKey = config.outputKey;
+    this.conditions = config.conditions;
+    this.logic = config.logic ?? "and";
+  }
+  async executeTick(context) {
+    try {
+      const varCtx = {
+        blackboard: context.blackboard,
+        input: context.input,
+        testData: context.testData
+      };
+      const inputResolved = typeof this.input === "string" ? resolveValue(this.input, varCtx) : this.input;
+      if (!Array.isArray(inputResolved)) {
+        throw new Error(
+          `Input is not an array: got ${inputResolved === null ? "null" : typeof inputResolved}`
+        );
+      }
+      const resolvedConditions = this.conditions.map((c) => ({
+        condition: c,
+        value: c.value !== void 0 ? resolveValue(c.value, varCtx) : void 0,
+        range: c.range ? [resolveValue(c.range[0], varCtx), resolveValue(c.range[1], varCtx)] : void 0
+      }));
+      const result = inputResolved.filter((item) => {
+        const results = resolvedConditions.map(
+          ({ condition, value, range }) => evaluateCondition(item, condition, value, range)
+        );
+        return this.logic === "and" ? results.every(Boolean) : results.some(Boolean);
+      });
+      context.blackboard.set(this.outputKey, result);
+      this.log(`Filtered ${inputResolved.length} \u2192 ${result.length} items`);
+      return "SUCCESS" /* SUCCESS */;
+    } catch (error) {
+      this._lastError = error instanceof Error ? error.message : String(error);
+      this.log(`ArrayFilter failed: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+  }
+};
+
+// src/utilities/aggregate.ts
+function getFieldValue2(item, path2) {
+  if (item === null || item === void 0) return void 0;
+  const parts = path2.split(".");
+  let current = item;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function computeAggregations(items, operations) {
+  const result = {};
+  for (const op of operations) {
+    const key = op.as ?? (op.field ? `${op.type}_${op.field}` : op.type);
+    if (op.type === "count") {
+      result[key] = items.length;
+      continue;
+    }
+    if (!op.field) {
+      result[key] = null;
+      continue;
+    }
+    const values = [];
+    for (const item of items) {
+      const raw = getFieldValue2(item, op.field);
+      const num = typeof raw === "number" ? raw : parseFloat(String(raw));
+      if (!isNaN(num)) values.push(num);
+    }
+    switch (op.type) {
+      case "sum":
+        result[key] = values.reduce((a, b) => a + b, 0);
+        break;
+      case "avg":
+        result[key] = values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0;
+        break;
+      case "min":
+        result[key] = values.length > 0 ? Math.min(...values) : null;
+        break;
+      case "max":
+        result[key] = values.length > 0 ? Math.max(...values) : null;
+        break;
+    }
+  }
+  return result;
+}
+var Aggregate = class extends ActionNode {
+  input;
+  outputKey;
+  operations;
+  groupBy;
+  constructor(config) {
+    super(config);
+    this.input = config.input;
+    this.outputKey = config.outputKey;
+    this.operations = config.operations;
+    this.groupBy = config.groupBy;
+  }
+  async executeTick(context) {
+    try {
+      const varCtx = {
+        blackboard: context.blackboard,
+        input: context.input,
+        testData: context.testData
+      };
+      const inputResolved = typeof this.input === "string" ? resolveValue(this.input, varCtx) : this.input;
+      if (!Array.isArray(inputResolved)) {
+        throw new Error(
+          `Input is not an array: got ${inputResolved === null ? "null" : typeof inputResolved}`
+        );
+      }
+      if (!this.groupBy) {
+        const result = computeAggregations(inputResolved, this.operations);
+        context.blackboard.set(this.outputKey, result);
+        this.log(`Aggregated ${inputResolved.length} items \u2192 ${JSON.stringify(result)}`);
+      } else {
+        const groups = {};
+        for (const item of inputResolved) {
+          const groupVal = getFieldValue2(item, this.groupBy);
+          const groupKey = groupVal === null || groupVal === void 0 ? "__null__" : String(groupVal);
+          if (!groups[groupKey]) groups[groupKey] = [];
+          groups[groupKey].push(item);
+        }
+        const result = {};
+        for (const [groupKey, groupItems] of Object.entries(groups)) {
+          result[groupKey] = computeAggregations(groupItems, this.operations);
+        }
+        context.blackboard.set(this.outputKey, result);
+        this.log(
+          `Aggregated ${inputResolved.length} items into ${Object.keys(groups).length} groups`
+        );
+      }
+      return "SUCCESS" /* SUCCESS */;
+    } catch (error) {
+      this._lastError = error instanceof Error ? error.message : String(error);
+      this.log(`Aggregate failed: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+  }
+};
+
+// src/utilities/threshold-check.ts
+function evaluateThreshold(val, threshold, resolvedValue, resolvedRange) {
+  switch (threshold.operator) {
+    case "lte":
+      return val <= resolvedValue;
+    case "lt":
+      return val < resolvedValue;
+    case "gte":
+      return val >= resolvedValue;
+    case "gt":
+      return val > resolvedValue;
+    case "eq":
+      return val === resolvedValue;
+    case "ne":
+      return val !== resolvedValue;
+    case "between": {
+      if (!resolvedRange) return false;
+      return val >= resolvedRange[0] && val <= resolvedRange[1];
+    }
+    default:
+      return false;
+  }
+}
+var ThresholdCheck = class extends ActionNode {
+  valueRef;
+  thresholds;
+  outputKey;
+  failOn;
+  constructor(config) {
+    super(config);
+    this.valueRef = config.value;
+    this.thresholds = config.thresholds;
+    this.outputKey = config.outputKey;
+    this.failOn = config.failOn ?? [];
+  }
+  async executeTick(context) {
+    try {
+      const varCtx = {
+        blackboard: context.blackboard,
+        input: context.input,
+        testData: context.testData
+      };
+      const resolved = typeof this.valueRef === "string" ? resolveValue(this.valueRef, varCtx) : this.valueRef;
+      const numValue = typeof resolved === "number" ? resolved : parseFloat(String(resolved));
+      if (isNaN(numValue)) {
+        throw new Error(`Value is not numeric: ${JSON.stringify(resolved)}`);
+      }
+      let matchedLabel = "normal";
+      for (const threshold of this.thresholds) {
+        const thresholdValue = threshold.value !== void 0 ? resolveValue(threshold.value, varCtx) : void 0;
+        const thresholdRange = threshold.range ? [resolveValue(threshold.range[0], varCtx), resolveValue(threshold.range[1], varCtx)] : void 0;
+        if (evaluateThreshold(numValue, threshold, thresholdValue, thresholdRange)) {
+          matchedLabel = threshold.label;
+          break;
+        }
+      }
+      if (this.outputKey) {
+        context.blackboard.set(this.outputKey, matchedLabel);
+      }
+      this.log(`Value ${numValue} \u2192 ${matchedLabel}`);
+      if (this.failOn.includes(matchedLabel)) {
+        this._lastError = `Threshold breach: ${matchedLabel} (value: ${numValue})`;
+        return "FAILURE" /* FAILURE */;
+      }
+      return "SUCCESS" /* SUCCESS */;
+    } catch (error) {
+      this._lastError = error instanceof Error ? error.message : String(error);
+      this.log(`ThresholdCheck failed: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+  }
+};
+
+// src/utilities/data-transform.ts
+function setNestedValue(obj, path2, value) {
+  const parts = path2.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0 || current[part] === null || typeof current[part] !== "object") {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  const lastPart = parts[parts.length - 1];
+  if (lastPart !== void 0) {
+    current[lastPart] = value;
+  }
+}
+function coerceValue(value, coerce) {
+  switch (coerce) {
+    case "string":
+      return value === null || value === void 0 ? "" : String(value);
+    case "number": {
+      if (typeof value === "number") return value;
+      const num = parseFloat(String(value));
+      if (isNaN(num)) throw new Error(`Cannot coerce "${value}" to number`);
+      return num;
+    }
+    case "boolean":
+      if (typeof value === "boolean") return value;
+      if (value === "true" || value === 1) return true;
+      if (value === "false" || value === 0 || value === "" || value === null || value === void 0) return false;
+      return Boolean(value);
+    default:
+      return value;
+  }
+}
+var DataTransform = class extends ActionNode {
+  outputKey;
+  mappings;
+  wrapInArray;
+  constructor(config) {
+    super(config);
+    this.outputKey = config.outputKey;
+    this.mappings = config.mappings;
+    this.wrapInArray = config.wrapInArray ?? false;
+  }
+  async executeTick(context) {
+    try {
+      const varCtx = {
+        blackboard: context.blackboard,
+        input: context.input,
+        testData: context.testData
+      };
+      const result = {};
+      for (const mapping of this.mappings) {
+        let resolved = resolveValue(mapping.value, varCtx);
+        if (mapping.coerce) {
+          resolved = coerceValue(resolved, mapping.coerce);
+        }
+        setNestedValue(result, mapping.target, resolved);
+      }
+      const output = this.wrapInArray ? [result] : result;
+      context.blackboard.set(this.outputKey, output);
+      this.log(`Built object with ${this.mappings.length} fields \u2192 ${this.outputKey}`);
+      return "SUCCESS" /* SUCCESS */;
+    } catch (error) {
+      this._lastError = error instanceof Error ? error.message : String(error);
+      this.log(`DataTransform failed: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+  }
+};
+
 // src/integrations/piece-executor.ts
 var PROVIDER_TO_PIECE = {
   // Google services
@@ -4988,6 +5628,11 @@ function registerStandardNodes(registry) {
   registry.register("LogMessage", LogMessage, { category: "action" });
   registry.register("RegexExtract", RegexExtract, { category: "action" });
   registry.register("SetVariable", SetVariable, { category: "action" });
+  registry.register("MathOp", MathOp, { category: "action" });
+  registry.register("ArrayFilter", ArrayFilter, { category: "action" });
+  registry.register("Aggregate", Aggregate, { category: "action" });
+  registry.register("ThresholdCheck", ThresholdCheck, { category: "action" });
+  registry.register("DataTransform", DataTransform, { category: "action" });
   registry.register("IntegrationAction", IntegrationAction, { category: "action" });
   registry.register("PythonScript", PythonScript, { category: "action" });
   registry.register("ParseFile", ParseFile, { category: "action" });
@@ -5837,7 +6482,9 @@ function createObservabilitySinkHandler(config = {}) {
 }
 export {
   ActionNode,
+  Aggregate,
   AlwaysCondition,
+  ArrayFilter,
   BaseNode,
   BehaviorTree,
   BrowserAgent,
@@ -5850,6 +6497,7 @@ export {
   ConfigValidationError,
   ConfigurationError,
   CounterAction,
+  DataTransform,
   DecoratorNode,
   Delay,
   ExecutionTracker,
@@ -5868,6 +6516,7 @@ export {
   LLMChat,
   LLMToolCall,
   LogMessage,
+  MathOp,
   MemoryDataStore,
   MemorySequence,
   MockAction,
@@ -5899,6 +6548,7 @@ export {
   StructureValidationError,
   SubTree,
   SuccessNode,
+  ThresholdCheck,
   Timeout,
   ToolExecutor,
   ToolRouter,
@@ -5929,6 +6579,7 @@ export {
   registerStandardNodes,
   resolveString,
   resolveValue,
+  safeEvaluate,
   safeValidateConfiguration,
   schemaRegistry,
   semanticValidator,