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

package/dist/index.js

@@ -2218,6 +2218,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
 import { CancellationScope, isCancellation } from "@temporalio/workflow";
 var Timeout = class extends DecoratorNode {
@@ -2495,8 +2541,81 @@ var humanTaskSchema = createNodeSchema("HumanTask", {
   outputKey: z5.string().optional()
 });
 
-// src/schemas/validation.ts
+// src/utilities/set-variable.schema.ts
 import { z as z6 } from "zod";
+var setVariableSchema = createNodeSchema("SetVariable", {
+  key: z6.string().min(1, "key is required"),
+  value: z6.unknown()
+});
+
+// src/actions/llm-tool-call.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 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")
+});
+
+// src/actions/tool-executor.schema.ts
+import { z as z8 } 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()
+});
+
+// src/actions/wait-for-signal.schema.ts
+import { z as z9 } 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")
+});
+
+// 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())
+});
+var ruleSchema = z10.object({
+  pattern: z10.string().min(1),
+  toolSets: z10.array(z10.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")
+});
+
+// src/decorators/streaming-sink.schema.ts
+import { z as z11 } from "zod";
+var streamingSinkSchema = createNodeSchema("StreamingSink", {
+  channelId: z11.string().optional(),
+  channelKey: z11.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";
 function zodErrorToConfigurationError(error, nodeType, nodeId) {
   const nodeIdentifier = nodeId ? `${nodeType}:${nodeId}` : nodeType;
   const issues = error.issues.map((issue) => {
@@ -2512,7 +2631,7 @@ function validateConfiguration(schema, config, nodeType, nodeId) {
   try {
     return schema.parse(config);
   } catch (error) {
-    if (error instanceof z6.ZodError) {
+    if (error instanceof z12.ZodError) {
       throw zodErrorToConfigurationError(error, nodeType, nodeId);
     }
     throw error;
@@ -2531,14 +2650,14 @@ function safeValidateConfiguration(schema, config, nodeType, nodeId) {
 }
 
 // src/schemas/tree-definition.schema.ts
-import { z as z7 } from "zod";
-var treeDefSchemaObject = z7.object({
-  type: z7.string().min(1, "Node type is required"),
-  id: z7.string().optional(),
-  name: z7.string().optional(),
-  props: z7.record(z7.string(), z7.unknown()).optional(),
-  children: z7.array(
-    z7.lazy(() => treeDefinitionSchema)
+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)
   ).optional()
 });
 var treeDefinitionSchema = treeDefSchemaObject;
@@ -2620,6 +2739,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
@@ -3089,8 +3214,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 "==":
@@ -3282,6 +3431,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
@@ -4448,6 +4626,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" });
@@ -4501,6 +4986,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" });
@@ -4512,6 +4998,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
@@ -5374,6 +5865,7 @@ export {
   Invert,
   KeepRunningUntilFailure,
   LLMChat,
+  LLMToolCall,
   LogMessage,
   MemoryDataStore,
   MemorySequence,
@@ -5400,14 +5892,19 @@ export {
   SemanticValidationError,
   Sequence,
   SequenceWithMemory,
+  SetVariable,
   SoftAssert,
+  StreamingSink,
   StructureValidationError,
   SubTree,
   SuccessNode,
   Timeout,
+  ToolExecutor,
+  ToolRouter,
   ValidationError,
   ValidationErrors,
   WaitAction,
+  WaitForSignal,
   While,
   YamlSyntaxError,
   clearPieceCache,