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

package/dist/index.cjs

@@ -31,7 +31,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ActionNode: () => ActionNode,
+  Aggregate: () => Aggregate,
   AlwaysCondition: () => AlwaysCondition,
+  ArrayFilter: () => ArrayFilter,
   BaseNode: () => BaseNode,
   BehaviorTree: () => BehaviorTree,
   BrowserAgent: () => BrowserAgent,
@@ -44,6 +46,7 @@ __export(index_exports, {
   ConfigValidationError: () => ConfigValidationError,
   ConfigurationError: () => ConfigurationError,
   CounterAction: () => CounterAction,
+  DataTransform: () => DataTransform,
   DecoratorNode: () => DecoratorNode,
   Delay: () => Delay,
   ExecutionTracker: () => ExecutionTracker,
@@ -62,6 +65,7 @@ __export(index_exports, {
   LLMChat: () => LLMChat,
   LLMToolCall: () => LLMToolCall,
   LogMessage: () => LogMessage,
+  MathOp: () => MathOp,
   MemoryDataStore: () => MemoryDataStore,
   MemorySequence: () => MemorySequence,
   MockAction: () => MockAction,
@@ -93,6 +97,7 @@ __export(index_exports, {
   StructureValidationError: () => StructureValidationError,
   SubTree: () => SubTree,
   SuccessNode: () => SuccessNode,
+  ThresholdCheck: () => ThresholdCheck,
   Timeout: () => Timeout,
   ToolExecutor: () => ToolExecutor,
   ToolRouter: () => ToolRouter,
@@ -123,6 +128,7 @@ __export(index_exports, {
   registerStandardNodes: () => registerStandardNodes,
   resolveString: () => resolveString,
   resolveValue: () => resolveValue,
+  safeEvaluate: () => safeEvaluate,
   safeValidateConfiguration: () => safeValidateConfiguration,
   schemaRegistry: () => schemaRegistry,
   semanticValidator: () => semanticValidator,
@@ -1187,6 +1193,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;
@@ -1210,7 +1231,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 */;
@@ -2690,74 +2711,153 @@ var setVariableSchema = createNodeSchema("SetVariable", {
   value: import_zod6.z.unknown()
 });
 
-// src/actions/llm-tool-call.schema.ts
+// src/utilities/math-op.schema.ts
 var import_zod7 = require("zod");
-var toolDefinitionSchema = import_zod7.z.object({
-  name: import_zod7.z.string().min(1),
-  description: import_zod7.z.string().min(1),
-  inputSchema: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown())
+var mathOpSchema = createNodeSchema("MathOp", {
+  expression: import_zod7.z.string().min(1, "expression is required"),
+  outputKey: import_zod7.z.string().min(1, "outputKey is required"),
+  round: import_zod7.z.enum(["none", "round", "floor", "ceil"]).optional(),
+  precision: import_zod7.z.number().int().nonnegative().optional()
+});
+
+// src/utilities/array-filter.schema.ts
+var import_zod8 = require("zod");
+var filterConditionSchema = import_zod8.z.object({
+  field: import_zod8.z.string().min(1),
+  operator: import_zod8.z.enum([
+    "eq",
+    "ne",
+    "gt",
+    "lt",
+    "gte",
+    "lte",
+    "in",
+    "nin",
+    "exists",
+    "regex",
+    "between",
+    "contains"
+  ]),
+  value: import_zod8.z.unknown().optional(),
+  range: import_zod8.z.tuple([import_zod8.z.unknown(), import_zod8.z.unknown()]).optional()
+});
+var arrayFilterSchema = createNodeSchema("ArrayFilter", {
+  input: import_zod8.z.string().min(1, "input is required"),
+  outputKey: import_zod8.z.string().min(1, "outputKey is required"),
+  conditions: import_zod8.z.array(filterConditionSchema).min(1, "at least one condition is required"),
+  logic: import_zod8.z.enum(["and", "or"]).optional()
+});
+
+// src/utilities/aggregate.schema.ts
+var import_zod9 = require("zod");
+var aggregateOperationSchema = import_zod9.z.object({
+  type: import_zod9.z.enum(["count", "sum", "avg", "min", "max"]),
+  field: import_zod9.z.string().optional(),
+  as: import_zod9.z.string().optional()
+});
+var aggregateSchema = createNodeSchema("Aggregate", {
+  input: import_zod9.z.string().min(1, "input is required"),
+  outputKey: import_zod9.z.string().min(1, "outputKey is required"),
+  operations: import_zod9.z.array(aggregateOperationSchema).min(1, "at least one operation is required"),
+  groupBy: import_zod9.z.string().optional()
+});
+
+// src/utilities/threshold-check.schema.ts
+var import_zod10 = require("zod");
+var thresholdLevelSchema = import_zod10.z.object({
+  operator: import_zod10.z.enum(["lte", "lt", "gte", "gt", "eq", "ne", "between"]),
+  value: import_zod10.z.unknown().optional(),
+  range: import_zod10.z.tuple([import_zod10.z.unknown(), import_zod10.z.unknown()]).optional(),
+  label: import_zod10.z.string().min(1, "label is required")
+});
+var thresholdCheckSchema = createNodeSchema("ThresholdCheck", {
+  value: import_zod10.z.unknown(),
+  thresholds: import_zod10.z.array(thresholdLevelSchema).min(1, "at least one threshold is required"),
+  outputKey: import_zod10.z.string().optional(),
+  failOn: import_zod10.z.array(import_zod10.z.string()).optional()
+});
+
+// src/utilities/data-transform.schema.ts
+var import_zod11 = require("zod");
+var transformMappingSchema = import_zod11.z.object({
+  target: import_zod11.z.string().min(1, "target is required"),
+  value: import_zod11.z.unknown(),
+  coerce: import_zod11.z.enum(["string", "number", "boolean"]).optional()
+});
+var dataTransformSchema = createNodeSchema("DataTransform", {
+  outputKey: import_zod11.z.string().min(1, "outputKey is required"),
+  mappings: import_zod11.z.array(transformMappingSchema).min(1, "at least one mapping is required"),
+  wrapInArray: import_zod11.z.boolean().optional()
+});
+
+// src/actions/llm-tool-call.schema.ts
+var import_zod12 = require("zod");
+var toolDefinitionSchema = import_zod12.z.object({
+  name: import_zod12.z.string().min(1),
+  description: import_zod12.z.string().min(1),
+  inputSchema: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown())
 });
 var llmToolCallSchema = createNodeSchema("LLMToolCall", {
-  provider: import_zod7.z.enum(["anthropic", "openai", "google", "ollama"]),
-  model: import_zod7.z.string().min(1, "Model is required"),
-  systemPrompt: import_zod7.z.string().optional(),
-  messagesKey: import_zod7.z.string().min(1, "messagesKey is required"),
-  userMessageKey: import_zod7.z.string().optional(),
-  toolsKey: import_zod7.z.string().optional(),
-  tools: import_zod7.z.array(toolDefinitionSchema).optional(),
-  temperature: import_zod7.z.number().min(0).max(2).optional(),
-  maxTokens: import_zod7.z.number().int().positive().optional(),
-  outputKey: import_zod7.z.string().min(1, "outputKey is required")
+  provider: import_zod12.z.enum(["anthropic", "openai", "google", "ollama"]),
+  model: import_zod12.z.string().min(1, "Model is required"),
+  systemPrompt: import_zod12.z.string().optional(),
+  messagesKey: import_zod12.z.string().min(1, "messagesKey is required"),
+  userMessageKey: import_zod12.z.string().optional(),
+  toolsKey: import_zod12.z.string().optional(),
+  tools: import_zod12.z.array(toolDefinitionSchema).optional(),
+  temperature: import_zod12.z.number().min(0).max(2).optional(),
+  maxTokens: import_zod12.z.number().int().positive().optional(),
+  outputKey: import_zod12.z.string().min(1, "outputKey is required")
 });
 
 // src/actions/tool-executor.schema.ts
-var import_zod8 = require("zod");
+var import_zod13 = require("zod");
 var toolExecutorSchema = createNodeSchema("ToolExecutor", {
-  responseKey: import_zod8.z.string().min(1, "responseKey is required"),
-  messagesKey: import_zod8.z.string().min(1, "messagesKey is required"),
-  outputKey: import_zod8.z.string().optional()
+  responseKey: import_zod13.z.string().min(1, "responseKey is required"),
+  messagesKey: import_zod13.z.string().min(1, "messagesKey is required"),
+  outputKey: import_zod13.z.string().optional()
 });
 
 // src/actions/wait-for-signal.schema.ts
-var import_zod9 = require("zod");
+var import_zod14 = require("zod");
 var waitForSignalSchema = createNodeSchema("WaitForSignal", {
-  signalName: import_zod9.z.string().min(1, "signalName is required"),
-  signalKey: import_zod9.z.string().optional(),
-  timeoutMs: import_zod9.z.number().int().positive().optional().default(864e5),
-  outputKey: import_zod9.z.string().min(1, "outputKey is required")
+  signalName: import_zod14.z.string().min(1, "signalName is required"),
+  signalKey: import_zod14.z.string().optional(),
+  timeoutMs: import_zod14.z.number().int().positive().optional().default(864e5),
+  outputKey: import_zod14.z.string().min(1, "outputKey is required")
 });
 
 // src/actions/tool-router.schema.ts
-var import_zod10 = require("zod");
-var toolDefinitionSchema2 = import_zod10.z.object({
-  name: import_zod10.z.string().min(1),
-  description: import_zod10.z.string().min(1),
-  inputSchema: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.unknown())
+var import_zod15 = require("zod");
+var toolDefinitionSchema2 = import_zod15.z.object({
+  name: import_zod15.z.string().min(1),
+  description: import_zod15.z.string().min(1),
+  inputSchema: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.unknown())
 });
-var ruleSchema = import_zod10.z.object({
-  pattern: import_zod10.z.string().min(1),
-  toolSets: import_zod10.z.array(import_zod10.z.string().min(1)).min(1)
+var ruleSchema = import_zod15.z.object({
+  pattern: import_zod15.z.string().min(1),
+  toolSets: import_zod15.z.array(import_zod15.z.string().min(1)).min(1)
 });
 var toolRouterSchema = createNodeSchema("ToolRouter", {
-  intentKey: import_zod10.z.string().min(1, "intentKey is required"),
-  toolSets: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.array(toolDefinitionSchema2)),
-  defaultTools: import_zod10.z.array(import_zod10.z.string()).optional(),
-  rules: import_zod10.z.array(ruleSchema).optional(),
-  outputKey: import_zod10.z.string().min(1, "outputKey is required")
+  intentKey: import_zod15.z.string().min(1, "intentKey is required"),
+  toolSets: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.array(toolDefinitionSchema2)),
+  defaultTools: import_zod15.z.array(import_zod15.z.string()).optional(),
+  rules: import_zod15.z.array(ruleSchema).optional(),
+  outputKey: import_zod15.z.string().min(1, "outputKey is required")
 });
 
 // src/decorators/streaming-sink.schema.ts
-var import_zod11 = require("zod");
+var import_zod16 = require("zod");
 var streamingSinkSchema = createNodeSchema("StreamingSink", {
-  channelId: import_zod11.z.string().optional(),
-  channelKey: import_zod11.z.string().optional()
+  channelId: import_zod16.z.string().optional(),
+  channelKey: import_zod16.z.string().optional()
 }).refine(
   (data) => data.channelId || data.channelKey,
   { message: "Either channelId or channelKey must be provided" }
 );
 
 // src/schemas/validation.ts
-var import_zod12 = require("zod");
+var import_zod17 = require("zod");
 function zodErrorToConfigurationError(error, nodeType, nodeId) {
   const nodeIdentifier = nodeId ? `${nodeType}:${nodeId}` : nodeType;
   const issues = error.issues.map((issue) => {
@@ -2773,7 +2873,7 @@ function validateConfiguration(schema, config, nodeType, nodeId) {
   try {
     return schema.parse(config);
   } catch (error) {
-    if (error instanceof import_zod12.z.ZodError) {
+    if (error instanceof import_zod17.z.ZodError) {
       throw zodErrorToConfigurationError(error, nodeType, nodeId);
     }
     throw error;
@@ -2792,14 +2892,14 @@ function safeValidateConfiguration(schema, config, nodeType, nodeId) {
 }
 
 // src/schemas/tree-definition.schema.ts
-var import_zod13 = require("zod");
-var treeDefSchemaObject = import_zod13.z.object({
-  type: import_zod13.z.string().min(1, "Node type is required"),
-  id: import_zod13.z.string().optional(),
-  name: import_zod13.z.string().optional(),
-  props: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()).optional(),
-  children: import_zod13.z.array(
-    import_zod13.z.lazy(() => treeDefinitionSchema)
+var import_zod18 = require("zod");
+var treeDefSchemaObject = import_zod18.z.object({
+  type: import_zod18.z.string().min(1, "Node type is required"),
+  id: import_zod18.z.string().optional(),
+  name: import_zod18.z.string().optional(),
+  props: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.unknown()).optional(),
+  children: import_zod18.z.array(
+    import_zod18.z.lazy(() => treeDefinitionSchema)
   ).optional()
 });
 var treeDefinitionSchema = treeDefSchemaObject;
@@ -2882,6 +2982,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);
@@ -3602,6 +3707,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
@@ -5130,6 +5776,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" });
@@ -5980,7 +6631,9 @@ function createObservabilitySinkHandler(config = {}) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ActionNode,
+  Aggregate,
   AlwaysCondition,
+  ArrayFilter,
   BaseNode,
   BehaviorTree,
   BrowserAgent,
@@ -5993,6 +6646,7 @@ function createObservabilitySinkHandler(config = {}) {
   ConfigValidationError,
   ConfigurationError,
   CounterAction,
+  DataTransform,
   DecoratorNode,
   Delay,
   ExecutionTracker,
@@ -6011,6 +6665,7 @@ function createObservabilitySinkHandler(config = {}) {
   LLMChat,
   LLMToolCall,
   LogMessage,
+  MathOp,
   MemoryDataStore,
   MemorySequence,
   MockAction,
@@ -6042,6 +6697,7 @@ function createObservabilitySinkHandler(config = {}) {
   StructureValidationError,
   SubTree,
   SuccessNode,
+  ThresholdCheck,
   Timeout,
   ToolExecutor,
   ToolRouter,
@@ -6072,6 +6728,7 @@ function createObservabilitySinkHandler(config = {}) {
   registerStandardNodes,
   resolveString,
   resolveValue,
+  safeEvaluate,
   safeValidateConfiguration,
   schemaRegistry,
   semanticValidator,