@q1k-oss/behaviour-tree-workflows 0.0.2 → 0.0.3

package/dist/index.cjs

@@ -60,6 +60,7 @@ __export(index_exports, {
   Invert: () => Invert,
   KeepRunningUntilFailure: () => KeepRunningUntilFailure,
   LLMChat: () => LLMChat,
+  LLMToolCall: () => LLMToolCall,
   LogMessage: () => LogMessage,
   MemoryDataStore: () => MemoryDataStore,
   MemorySequence: () => MemorySequence,
@@ -86,14 +87,19 @@ __export(index_exports, {
   SemanticValidationError: () => SemanticValidationError,
   Sequence: () => Sequence,
   SequenceWithMemory: () => SequenceWithMemory,
+  SetVariable: () => SetVariable,
   SoftAssert: () => SoftAssert,
+  StreamingSink: () => StreamingSink,
   StructureValidationError: () => StructureValidationError,
   SubTree: () => SubTree,
   SuccessNode: () => SuccessNode,
   Timeout: () => Timeout,
+  ToolExecutor: () => ToolExecutor,
+  ToolRouter: () => ToolRouter,
   ValidationError: () => ValidationError,
   ValidationErrors: () => ValidationErrors,
   WaitAction: () => WaitAction,
+  WaitForSignal: () => WaitForSignal,
   While: () => While,
   YamlSyntaxError: () => YamlSyntaxError,
   clearPieceCache: () => clearPieceCache,
@@ -2354,6 +2360,52 @@ var SoftAssert = class extends DecoratorNode {
   }
 };
 
+// src/decorators/streaming-sink.ts
+var StreamingSink = class extends DecoratorNode {
+  channelId;
+  channelKey;
+  constructor(config) {
+    super(config);
+    if (!config.channelId && !config.channelKey) {
+      throw new ConfigurationError(
+        "StreamingSink requires either channelId or channelKey"
+      );
+    }
+    this.channelId = config.channelId;
+    this.channelKey = config.channelKey;
+  }
+  async executeTick(context) {
+    if (!this.child) {
+      throw new ConfigurationError(
+        `${this.name}: Decorator must have a child`
+      );
+    }
+    let resolvedChannelId = this.channelId;
+    if (this.channelKey) {
+      const varCtx = {
+        blackboard: context.blackboard,
+        input: context.input,
+        testData: context.testData
+      };
+      resolvedChannelId = resolveValue(this.channelKey, varCtx);
+    }
+    const previousValue = context.blackboard.get("__streamChannelId");
+    context.blackboard.set("__streamChannelId", resolvedChannelId);
+    this.log(`Set streaming channel: ${resolvedChannelId}`);
+    try {
+      const childStatus = await this.child.tick(context);
+      this._status = childStatus;
+      return childStatus;
+    } finally {
+      if (previousValue !== void 0) {
+        context.blackboard.set("__streamChannelId", previousValue);
+      } else {
+        context.blackboard.delete("__streamChannelId");
+      }
+    }
+  }
+};
+
 // src/decorators/timeout.ts
 var import_workflow2 = require("@temporalio/workflow");
 var Timeout = class extends DecoratorNode {
@@ -2631,8 +2683,81 @@ var humanTaskSchema = createNodeSchema("HumanTask", {
   outputKey: import_zod5.z.string().optional()
 });
 
-// src/schemas/validation.ts
+// src/utilities/set-variable.schema.ts
 var import_zod6 = require("zod");
+var setVariableSchema = createNodeSchema("SetVariable", {
+  key: import_zod6.z.string().min(1, "key is required"),
+  value: import_zod6.z.unknown()
+});
+
+// src/actions/llm-tool-call.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 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")
+});
+
+// src/actions/tool-executor.schema.ts
+var import_zod8 = 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()
+});
+
+// src/actions/wait-for-signal.schema.ts
+var import_zod9 = 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")
+});
+
+// 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 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 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")
+});
+
+// src/decorators/streaming-sink.schema.ts
+var import_zod11 = require("zod");
+var streamingSinkSchema = createNodeSchema("StreamingSink", {
+  channelId: import_zod11.z.string().optional(),
+  channelKey: import_zod11.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");
 function zodErrorToConfigurationError(error, nodeType, nodeId) {
   const nodeIdentifier = nodeId ? `${nodeType}:${nodeId}` : nodeType;
   const issues = error.issues.map((issue) => {
@@ -2648,7 +2773,7 @@ function validateConfiguration(schema, config, nodeType, nodeId) {
   try {
     return schema.parse(config);
   } catch (error) {
-    if (error instanceof import_zod6.z.ZodError) {
+    if (error instanceof import_zod12.z.ZodError) {
       throw zodErrorToConfigurationError(error, nodeType, nodeId);
     }
     throw error;
@@ -2667,14 +2792,14 @@ function safeValidateConfiguration(schema, config, nodeType, nodeId) {
 }
 
 // src/schemas/tree-definition.schema.ts
-var import_zod7 = require("zod");
-var treeDefSchemaObject = import_zod7.z.object({
-  type: import_zod7.z.string().min(1, "Node type is required"),
-  id: import_zod7.z.string().optional(),
-  name: import_zod7.z.string().optional(),
-  props: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).optional(),
-  children: import_zod7.z.array(
-    import_zod7.z.lazy(() => treeDefinitionSchema)
+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)
   ).optional()
 });
 var treeDefinitionSchema = treeDefSchemaObject;
@@ -2756,6 +2881,12 @@ var SchemaRegistry = class {
     this.register("LLMChat", llmChatSchema);
     this.register("BrowserAgent", browserAgentSchema);
     this.register("HumanTask", humanTaskSchema);
+    this.register("SetVariable", setVariableSchema);
+    this.register("LLMToolCall", llmToolCallSchema);
+    this.register("ToolExecutor", toolExecutorSchema);
+    this.register("WaitForSignal", waitForSignalSchema);
+    this.register("ToolRouter", toolRouterSchema);
+    this.register("StreamingSink", streamingSinkSchema);
   }
   /**
    * Register a validation schema for a node type
@@ -3225,8 +3356,32 @@ var CheckCondition = class extends ConditionNode {
     this.operator = config.operator || "==";
     this.value = config.value;
   }
+  /**
+   * Resolve a potentially dotted key from the blackboard.
+   * Tries exact key first (backward compatible), then dotted path traversal.
+   */
+  resolveBlackboardValue(context) {
+    const exact = context.blackboard.get(this.key);
+    if (exact !== void 0) {
+      return exact;
+    }
+    if (this.key.includes(".")) {
+      const segments = this.key.split(".");
+      const rootKey = segments[0];
+      let current = context.blackboard.get(rootKey);
+      for (let i = 1; i < segments.length; i++) {
+        if (current == null || typeof current !== "object") {
+          return void 0;
+        }
+        const segment = segments[i];
+        current = current[segment];
+      }
+      return current;
+    }
+    return void 0;
+  }
   async executeTick(context) {
-    const actualValue = context.blackboard.get(this.key);
+    const actualValue = this.resolveBlackboardValue(context);
     let result = false;
     switch (this.operator) {
       case "==":
@@ -3418,6 +3573,35 @@ var RegexExtract = class extends ActionNode {
   }
 };
 
+// src/utilities/set-variable.ts
+var SetVariable = class extends ActionNode {
+  key;
+  value;
+  constructor(config) {
+    super(config);
+    this.key = config.key;
+    this.value = config.value;
+  }
+  async executeTick(context) {
+    try {
+      const varCtx = {
+        blackboard: context.blackboard,
+        input: context.input,
+        testData: context.testData
+      };
+      const resolvedKey = typeof this.key === "string" ? resolveValue(this.key, varCtx) : String(this.key);
+      const resolvedValue = typeof this.value === "string" ? resolveValue(this.value, varCtx) : this.value;
+      context.blackboard.set(resolvedKey, resolvedValue);
+      this.log(`Set ${resolvedKey} = ${JSON.stringify(resolvedValue)}`);
+      return "SUCCESS" /* SUCCESS */;
+    } catch (error) {
+      this._lastError = error instanceof Error ? error.message : String(error);
+      this.log(`SetVariable failed: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+  }
+};
+
 // src/integrations/piece-executor.ts
 var PROVIDER_TO_PIECE = {
   // Google services
@@ -4584,6 +4768,313 @@ function setNestedPath(obj, path2, value) {
   }
 }
 
+// src/actions/llm-tool-call.ts
+var LLMToolCall = class extends ActionNode {
+  provider;
+  model;
+  systemPrompt;
+  messagesKey;
+  userMessageKey;
+  toolsKey;
+  tools;
+  temperature;
+  maxTokens;
+  outputKey;
+  constructor(config) {
+    super(config);
+    if (!config.provider) {
+      throw new ConfigurationError("LLMToolCall requires provider");
+    }
+    if (!config.model) {
+      throw new ConfigurationError("LLMToolCall requires model");
+    }
+    if (!config.messagesKey) {
+      throw new ConfigurationError("LLMToolCall requires messagesKey");
+    }
+    if (!config.outputKey) {
+      throw new ConfigurationError("LLMToolCall requires outputKey");
+    }
+    this.provider = config.provider;
+    this.model = config.model;
+    this.systemPrompt = config.systemPrompt;
+    this.messagesKey = config.messagesKey;
+    this.userMessageKey = config.userMessageKey;
+    this.toolsKey = config.toolsKey;
+    this.tools = config.tools;
+    this.temperature = config.temperature;
+    this.maxTokens = config.maxTokens;
+    this.outputKey = config.outputKey;
+  }
+  async executeTick(context) {
+    if (!context.activities?.agentLoopTurn) {
+      this._lastError = "LLMToolCall requires activities.agentLoopTurn to be configured.";
+      this.log(`Error: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+    try {
+      const varCtx = {
+        blackboard: context.blackboard,
+        input: context.input,
+        testData: context.testData
+      };
+      let messages = context.blackboard.get(this.messagesKey) || [];
+      if (this.userMessageKey) {
+        const userMsg = context.blackboard.get(this.userMessageKey);
+        if (userMsg !== void 0 && userMsg !== null) {
+          const content = typeof userMsg === "string" ? userMsg : String(userMsg);
+          messages = [...messages, { role: "user", content }];
+          context.blackboard.set(this.userMessageKey, null);
+        }
+      }
+      const tools = this.toolsKey ? context.blackboard.get(this.toolsKey) || [] : this.tools || [];
+      const resolvedModel = resolveValue(this.model, varCtx);
+      const resolvedSystemPrompt = this.systemPrompt ? resolveValue(this.systemPrompt, varCtx) : void 0;
+      const streamChannelId = context.blackboard.get("__streamChannelId");
+      const request = {
+        provider: this.provider,
+        model: resolvedModel,
+        systemPrompt: resolvedSystemPrompt,
+        messages,
+        tools: tools.length > 0 ? tools : void 0,
+        temperature: this.temperature,
+        maxTokens: this.maxTokens,
+        streamChannelId: streamChannelId || void 0
+      };
+      this.log(
+        `LLMToolCall ${this.provider}/${resolvedModel} - ${messages.length} messages, ${tools.length} tools`
+      );
+      const result = await context.activities.agentLoopTurn(request);
+      if (result.toolCalls && result.toolCalls.length > 0) {
+        const contentBlocks = [];
+        if (result.content) {
+          contentBlocks.push({ type: "text", text: result.content });
+        }
+        for (const tc of result.toolCalls) {
+          contentBlocks.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.name,
+            input: tc.input
+          });
+        }
+        messages = [...messages, { role: "assistant", content: contentBlocks }];
+      } else {
+        messages = [...messages, { role: "assistant", content: result.content }];
+      }
+      context.blackboard.set(this.messagesKey, messages);
+      context.blackboard.set(this.outputKey, {
+        content: result.content,
+        toolCalls: result.toolCalls,
+        stopReason: result.stopReason,
+        usage: result.usage
+      });
+      this.log(
+        `LLMToolCall completed: stopReason=${result.stopReason}, tools=${result.toolCalls?.length || 0}, tokens=${result.usage.totalTokens}`
+      );
+      return "SUCCESS" /* SUCCESS */;
+    } catch (error) {
+      this._lastError = error instanceof Error ? error.message : String(error);
+      this.log(`LLMToolCall failed: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+  }
+};
+
+// src/actions/tool-executor.ts
+var ToolExecutor = class extends ActionNode {
+  responseKey;
+  messagesKey;
+  outputKey;
+  constructor(config) {
+    super(config);
+    if (!config.responseKey) {
+      throw new ConfigurationError("ToolExecutor requires responseKey");
+    }
+    if (!config.messagesKey) {
+      throw new ConfigurationError("ToolExecutor requires messagesKey");
+    }
+    this.responseKey = config.responseKey;
+    this.messagesKey = config.messagesKey;
+    this.outputKey = config.outputKey;
+  }
+  async executeTick(context) {
+    if (!context.activities?.executeAgentTool) {
+      this._lastError = "ToolExecutor requires activities.executeAgentTool to be configured.";
+      this.log(`Error: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+    try {
+      const response = context.blackboard.get(this.responseKey);
+      const toolCalls = response?.toolCalls;
+      if (!toolCalls || toolCalls.length === 0) {
+        this.log("No tool calls to execute");
+        return "SUCCESS" /* SUCCESS */;
+      }
+      const toolResults = [];
+      for (const tc of toolCalls) {
+        this.log(`Executing tool: ${tc.name} (${tc.id})`);
+        const result = await context.activities.executeAgentTool({
+          toolName: tc.name,
+          toolInput: tc.input
+        });
+        toolResults.push({
+          toolUseId: tc.id,
+          toolName: tc.name,
+          content: result.content,
+          isError: result.isError
+        });
+        this.log(
+          `Tool ${tc.name} ${result.isError ? "errored" : "completed"}: ${result.content.substring(0, 100)}`
+        );
+      }
+      const resultBlocks = toolResults.map((tr) => ({
+        type: "tool_result",
+        tool_use_id: tr.toolUseId,
+        content: tr.content,
+        is_error: tr.isError
+      }));
+      const messages = context.blackboard.get(this.messagesKey) || [];
+      const updatedMessages = [
+        ...messages,
+        { role: "user", content: resultBlocks }
+      ];
+      context.blackboard.set(this.messagesKey, updatedMessages);
+      if (this.outputKey) {
+        context.blackboard.set(this.outputKey, toolResults);
+      }
+      this.log(`Executed ${toolResults.length} tool(s), results appended to conversation`);
+      return "SUCCESS" /* SUCCESS */;
+    } catch (error) {
+      this._lastError = error instanceof Error ? error.message : String(error);
+      this.log(`ToolExecutor failed: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+  }
+};
+
+// src/actions/wait-for-signal.ts
+var WaitForSignal = class extends ActionNode {
+  signalName;
+  signalKey;
+  timeoutMs;
+  outputKey;
+  constructor(config) {
+    super(config);
+    if (!config.signalName) {
+      throw new ConfigurationError("WaitForSignal requires signalName");
+    }
+    if (!config.outputKey) {
+      throw new ConfigurationError("WaitForSignal requires outputKey");
+    }
+    this.signalName = config.signalName;
+    this.signalKey = config.signalKey;
+    this.timeoutMs = config.timeoutMs ?? 864e5;
+    this.outputKey = config.outputKey;
+  }
+  async executeTick(context) {
+    if (!context.activities?.waitForSignal) {
+      this._lastError = "WaitForSignal requires activities.waitForSignal to be configured. This is implemented as a Temporal condition in the workflow layer.";
+      this.log(`Error: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+    try {
+      const varCtx = {
+        blackboard: context.blackboard,
+        input: context.input,
+        testData: context.testData
+      };
+      const resolvedSignalKey = this.signalKey ? resolveValue(this.signalKey, varCtx) : void 0;
+      this.log(
+        `Waiting for signal "${this.signalName}"${resolvedSignalKey ? `:${resolvedSignalKey}` : ""} (timeout: ${this.timeoutMs}ms)`
+      );
+      const result = await context.activities.waitForSignal({
+        signalName: this.signalName,
+        signalKey: resolvedSignalKey,
+        timeoutMs: this.timeoutMs
+      });
+      if (result.timedOut) {
+        this._lastError = `Signal "${this.signalName}" timed out after ${this.timeoutMs}ms`;
+        this.log(this._lastError);
+        return "FAILURE" /* FAILURE */;
+      }
+      context.blackboard.set(this.outputKey, result.data);
+      this.log(`Signal received, data stored at "${this.outputKey}"`);
+      return "SUCCESS" /* SUCCESS */;
+    } catch (error) {
+      this._lastError = error instanceof Error ? error.message : String(error);
+      this.log(`WaitForSignal failed: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+  }
+};
+
+// src/actions/tool-router.ts
+var ToolRouter = class extends ActionNode {
+  intentKey;
+  toolSets;
+  defaultTools;
+  rules;
+  outputKey;
+  constructor(config) {
+    super(config);
+    if (!config.intentKey) {
+      throw new ConfigurationError("ToolRouter requires intentKey");
+    }
+    if (!config.toolSets || Object.keys(config.toolSets).length === 0) {
+      throw new ConfigurationError("ToolRouter requires at least one toolSet");
+    }
+    if (!config.outputKey) {
+      throw new ConfigurationError("ToolRouter requires outputKey");
+    }
+    this.intentKey = config.intentKey;
+    this.toolSets = config.toolSets;
+    this.defaultTools = config.defaultTools || [];
+    this.rules = config.rules || [];
+    this.outputKey = config.outputKey;
+  }
+  async executeTick(context) {
+    try {
+      const varCtx = {
+        blackboard: context.blackboard,
+        input: context.input,
+        testData: context.testData
+      };
+      const intentRaw = context.blackboard.get(this.intentKey);
+      const intent = typeof intentRaw === "string" ? intentRaw : "";
+      const selectedSetNames = new Set(this.defaultTools);
+      for (const rule of this.rules) {
+        const regex = new RegExp(rule.pattern, "i");
+        if (regex.test(intent)) {
+          for (const setName of rule.toolSets) {
+            selectedSetNames.add(setName);
+          }
+        }
+      }
+      const toolsByName = /* @__PURE__ */ new Map();
+      for (const setName of selectedSetNames) {
+        const tools = this.toolSets[setName];
+        if (tools) {
+          for (const tool of tools) {
+            if (!toolsByName.has(tool.name)) {
+              toolsByName.set(tool.name, tool);
+            }
+          }
+        }
+      }
+      const selectedTools = Array.from(toolsByName.values());
+      context.blackboard.set(this.outputKey, selectedTools);
+      this.log(
+        `Selected ${selectedTools.length} tools from sets [${Array.from(selectedSetNames).join(", ")}] for intent "${intent.substring(0, 50)}"`
+      );
+      return "SUCCESS" /* SUCCESS */;
+    } catch (error) {
+      this._lastError = error instanceof Error ? error.message : String(error);
+      this.log(`ToolRouter failed: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+  }
+};
+
 // src/registry-utils.ts
 function registerStandardNodes(registry) {
   registry.register("Sequence", Sequence, { category: "composite" });
@@ -4637,6 +5128,7 @@ function registerStandardNodes(registry) {
   registry.register("WaitAction", WaitAction, { category: "action" });
   registry.register("LogMessage", LogMessage, { category: "action" });
   registry.register("RegexExtract", RegexExtract, { category: "action" });
+  registry.register("SetVariable", SetVariable, { category: "action" });
   registry.register("IntegrationAction", IntegrationAction, { category: "action" });
   registry.register("PythonScript", PythonScript, { category: "action" });
   registry.register("ParseFile", ParseFile, { category: "action" });
@@ -4648,6 +5140,11 @@ function registerStandardNodes(registry) {
   registry.register("ClaudeAgent", ClaudeAgent, { category: "action" });
   registry.register("GitHubAction", GitHubAction, { category: "action" });
   registry.register("HumanTask", HumanTask, { category: "action" });
+  registry.register("LLMToolCall", LLMToolCall, { category: "action" });
+  registry.register("ToolExecutor", ToolExecutor, { category: "action" });
+  registry.register("WaitForSignal", WaitForSignal, { category: "action" });
+  registry.register("ToolRouter", ToolRouter, { category: "action" });
+  registry.register("StreamingSink", StreamingSink, { category: "decorator" });
 }
 
 // src/data-store/memory-store.ts
@@ -5511,6 +6008,7 @@ function createObservabilitySinkHandler(config = {}) {
   Invert,
   KeepRunningUntilFailure,
   LLMChat,
+  LLMToolCall,
   LogMessage,
   MemoryDataStore,
   MemorySequence,
@@ -5537,14 +6035,19 @@ function createObservabilitySinkHandler(config = {}) {
   SemanticValidationError,
   Sequence,
   SequenceWithMemory,
+  SetVariable,
   SoftAssert,
+  StreamingSink,
   StructureValidationError,
   SubTree,
   SuccessNode,
   Timeout,
+  ToolExecutor,
+  ToolRouter,
   ValidationError,
   ValidationErrors,
   WaitAction,
+  WaitForSignal,
   While,
   YamlSyntaxError,
   clearPieceCache,