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

package/dist/index.js

@@ -286,6 +286,19 @@ var ActionNode = class extends BaseNode {
       });
       const status = await this.executeTick(context);
       this._status = status;
+      if (status === "FAILURE" /* FAILURE */ && this._lastError) {
+        context.eventEmitter?.emit({
+          type: "error" /* ERROR */,
+          nodeId: this.id,
+          nodeName: this.name,
+          nodeType: this.type,
+          timestamp: Date.now(),
+          data: {
+            error: { message: this._lastError },
+            blackboard: context.blackboard?.toJSON?.() ?? {}
+          }
+        });
+      }
       context.eventEmitter?.emit({
         type: "tick_end" /* TICK_END */,
         nodeId: this.id,
@@ -352,6 +365,19 @@ var ConditionNode = class extends BaseNode {
       });
       const status = await this.executeTick(context);
       this._status = status;
+      if (status === "FAILURE" /* FAILURE */ && this._lastError) {
+        context.eventEmitter?.emit({
+          type: "error" /* ERROR */,
+          nodeId: this.id,
+          nodeName: this.name,
+          nodeType: this.type,
+          timestamp: Date.now(),
+          data: {
+            error: { message: this._lastError },
+            blackboard: context.blackboard?.toJSON?.() ?? {}
+          }
+        });
+      }
       context.eventEmitter?.emit({
         type: "tick_end" /* TICK_END */,
         nodeId: this.id,
@@ -830,9 +856,9 @@ var BehaviorTree = class _BehaviorTree {
    *
    * @example
    * ```typescript
-   * import { BehaviorTree } from '@wayfarer-ai/btree';
-   * import { Sequence } from '@wayfarer-ai/btree';
-   * import { PrintAction } from '@wayfarer-ai/btree';
+   * import { BehaviorTree } from '@q1k-oss/behaviour-tree-workflows';
+   * import { Sequence } from '@q1k-oss/behaviour-tree-workflows';
+   * import { PrintAction } from '@q1k-oss/behaviour-tree-workflows';
    *
    * const root = new Sequence({ id: 'root' });
    * root.addChild(new PrintAction({ id: 'step1', message: 'Hello' }));
@@ -2192,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 {
@@ -2414,8 +2486,136 @@ var memorySequenceConfigurationSchema = nodeConfigurationSchema;
 // src/composites/recovery.schema.ts
 var recoveryConfigurationSchema = nodeConfigurationSchema;
 
-// src/schemas/validation.ts
+// src/actions/llm-chat.schema.ts
 import { z as z3 } from "zod";
+var messageSchema = z3.object({
+  role: z3.enum(["system", "user", "assistant"]),
+  content: z3.string().min(1, "Message content cannot be empty")
+});
+var llmChatSchema = createNodeSchema("LLMChat", {
+  provider: z3.enum(["anthropic", "openai", "google", "ollama"]),
+  model: z3.string().min(1, "Model is required"),
+  messages: z3.array(messageSchema).min(1, "At least one message is required"),
+  systemPrompt: z3.string().optional(),
+  temperature: z3.number().min(0).max(2).optional(),
+  maxTokens: z3.number().int().positive().optional(),
+  responseFormat: z3.enum(["text", "json"]).optional().default("text"),
+  jsonSchema: z3.record(z3.string(), z3.unknown()).optional(),
+  timeout: z3.number().int().positive().optional().default(6e4),
+  baseUrl: z3.string().url().optional(),
+  outputKey: z3.string().min(1, "outputKey is required")
+});
+
+// src/actions/browser-agent.schema.ts
+import { z as z4 } from "zod";
+var browserAgentSchema = createNodeSchema("BrowserAgent", {
+  goal: z4.string().min(1, "Goal is required"),
+  startUrl: z4.string().optional(),
+  contextKey: z4.string().optional(),
+  persistContext: z4.boolean().optional().default(false),
+  timeout: z4.number().int().positive().optional().default(6e4),
+  maxSteps: z4.number().int().positive().optional().default(20),
+  llmProvider: z4.enum(["anthropic", "openai", "google", "ollama"]).optional(),
+  llmModel: z4.string().optional(),
+  outputKey: z4.string().min(1, "outputKey is required")
+});
+
+// src/actions/human-task.schema.ts
+import { z as z5 } from "zod";
+var a2uiComponentSchema = z5.object({
+  id: z5.string().min(1, "Component ID cannot be empty"),
+  component: z5.record(z5.string(), z5.unknown()),
+  weight: z5.number().optional()
+});
+var humanTaskSchema = createNodeSchema("HumanTask", {
+  title: z5.string().min(1, "Title is required"),
+  description: z5.string().optional(),
+  assignee: z5.string().optional(),
+  assigneeRole: z5.string().optional(),
+  a2ui: z5.object({
+    components: z5.array(a2uiComponentSchema).min(1, "At least one A2UI component is required"),
+    dataBindings: z5.record(z5.string(), z5.string()).optional()
+  }),
+  timeoutMs: z5.number().int().positive().optional().default(864e5),
+  onTimeout: z5.enum(["expire", "approve", "reject"]).optional().default("expire"),
+  outputKey: z5.string().optional()
+});
+
+// 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) => {
@@ -2431,7 +2631,7 @@ function validateConfiguration(schema, config, nodeType, nodeId) {
   try {
     return schema.parse(config);
   } catch (error) {
-    if (error instanceof z3.ZodError) {
+    if (error instanceof z12.ZodError) {
       throw zodErrorToConfigurationError(error, nodeType, nodeId);
     }
     throw error;
@@ -2450,14 +2650,14 @@ function safeValidateConfiguration(schema, config, nodeType, nodeId) {
 }
 
 // src/schemas/tree-definition.schema.ts
-import { z as z4 } from "zod";
-var treeDefSchemaObject = z4.object({
-  type: z4.string().min(1, "Node type is required"),
-  id: z4.string().optional(),
-  name: z4.string().optional(),
-  props: z4.record(z4.string(), z4.unknown()).optional(),
-  children: z4.array(
-    z4.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;
@@ -2536,6 +2736,15 @@ var SchemaRegistry = class {
     this.register("ReactiveSequence", reactiveSequenceConfigurationSchema);
     this.register("MemorySequence", memorySequenceConfigurationSchema);
     this.register("Recovery", recoveryConfigurationSchema);
+    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
@@ -3005,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 "==":
@@ -3198,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
@@ -3889,6 +4151,788 @@ var CodeExecution = class extends ActionNode {
   }
 };
 
+// src/actions/llm-chat.ts
+var LLMChat = class extends ActionNode {
+  provider;
+  model;
+  messages;
+  systemPrompt;
+  temperature;
+  maxTokens;
+  responseFormat;
+  jsonSchema;
+  timeout;
+  baseUrl;
+  outputKey;
+  constructor(config) {
+    super(config);
+    if (!config.provider) {
+      throw new ConfigurationError("LLMChat requires provider");
+    }
+    if (!config.model) {
+      throw new ConfigurationError("LLMChat requires model");
+    }
+    if (!config.messages || config.messages.length === 0) {
+      throw new ConfigurationError(
+        "LLMChat requires at least one message"
+      );
+    }
+    if (!config.outputKey) {
+      throw new ConfigurationError("LLMChat requires outputKey");
+    }
+    this.provider = config.provider;
+    this.model = config.model;
+    this.messages = config.messages;
+    this.systemPrompt = config.systemPrompt;
+    this.temperature = config.temperature;
+    this.maxTokens = config.maxTokens;
+    this.responseFormat = config.responseFormat || "text";
+    this.jsonSchema = config.jsonSchema;
+    this.timeout = config.timeout;
+    this.baseUrl = config.baseUrl;
+    this.outputKey = config.outputKey;
+  }
+  async executeTick(context) {
+    if (!context.activities?.llmChat) {
+      this._lastError = "LLMChat requires activities.llmChat to be configured. This activity handles LLM API calls outside the workflow sandbox.";
+      this.log(`Error: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+    try {
+      const varCtx = {
+        blackboard: context.blackboard,
+        input: context.input,
+        testData: context.testData
+      };
+      const resolvedMessages = this.messages.map((msg) => ({
+        role: msg.role,
+        content: resolveValue(msg.content, varCtx)
+      }));
+      const resolvedSystemPrompt = this.systemPrompt ? resolveValue(this.systemPrompt, varCtx) : void 0;
+      const resolvedModel = resolveValue(this.model, varCtx);
+      const request = {
+        provider: this.provider,
+        model: resolvedModel,
+        messages: resolvedMessages,
+        systemPrompt: resolvedSystemPrompt,
+        temperature: this.temperature,
+        maxTokens: this.maxTokens,
+        responseFormat: this.responseFormat,
+        jsonSchema: this.jsonSchema,
+        timeout: this.timeout,
+        baseUrl: this.baseUrl
+      };
+      this.log(
+        `LLM ${this.provider}/${resolvedModel} - ${resolvedMessages.length} messages`
+      );
+      const result = await context.activities.llmChat(request);
+      context.blackboard.set(this.outputKey, result);
+      if (result.finishReason === "error") {
+        this._lastError = `LLM returned error: ${result.content}`;
+        this.log(`Error: ${this._lastError}`);
+        return "FAILURE" /* FAILURE */;
+      }
+      this.log(
+        `LLM ${this.provider}/${resolvedModel} completed: ${result.usage.totalTokens} tokens, finish: ${result.finishReason}`
+      );
+      return "SUCCESS" /* SUCCESS */;
+    } catch (error) {
+      this._lastError = error instanceof Error ? error.message : String(error);
+      this.log(`LLM chat failed: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+  }
+};
+
+// src/actions/browser-agent.ts
+var BrowserAgent = class extends ActionNode {
+  goal;
+  startUrl;
+  contextKey;
+  persistContext;
+  timeout;
+  maxSteps;
+  llmProvider;
+  llmModel;
+  outputKey;
+  constructor(config) {
+    super(config);
+    if (!config.goal) {
+      throw new ConfigurationError("BrowserAgent requires goal");
+    }
+    if (!config.outputKey) {
+      throw new ConfigurationError("BrowserAgent requires outputKey");
+    }
+    this.goal = config.goal;
+    this.startUrl = config.startUrl;
+    this.contextKey = config.contextKey;
+    this.persistContext = config.persistContext ?? false;
+    this.timeout = config.timeout;
+    this.maxSteps = config.maxSteps;
+    this.llmProvider = config.llmProvider;
+    this.llmModel = config.llmModel;
+    this.outputKey = config.outputKey;
+  }
+  async executeTick(context) {
+    if (!context.activities?.browserAgent) {
+      this._lastError = "BrowserAgent requires activities.browserAgent to be configured. This activity handles browser automation via Browserbase + Stagehand.";
+      this.log(`Error: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+    try {
+      const varCtx = {
+        blackboard: context.blackboard,
+        input: context.input,
+        testData: context.testData
+      };
+      const resolvedGoal = resolveValue(this.goal, varCtx);
+      const resolvedStartUrl = this.startUrl ? resolveValue(this.startUrl, varCtx) : void 0;
+      const contextId = this.contextKey ? context.blackboard.get(this.contextKey) : void 0;
+      const request = {
+        goal: resolvedGoal,
+        startUrl: resolvedStartUrl,
+        contextId,
+        persistContext: this.persistContext,
+        timeout: this.timeout,
+        maxSteps: this.maxSteps,
+        llmProvider: this.llmProvider,
+        llmModel: this.llmModel
+      };
+      this.log(
+        `Browser agent: ${resolvedGoal.substring(0, 50)}${resolvedGoal.length > 50 ? "..." : ""}`
+      );
+      const result = await context.activities.browserAgent(request);
+      if (this.contextKey && result.contextId) {
+        context.blackboard.set(this.contextKey, result.contextId);
+      }
+      context.blackboard.set(this.outputKey, result);
+      if (!result.success) {
+        this._lastError = `Browser agent failed to achieve goal: ${result.message}`;
+        this.log(`Error: ${this._lastError}`);
+        this.log(`Debug session: ${result.debugUrl}`);
+        return "FAILURE" /* FAILURE */;
+      }
+      if (!result.completed) {
+        this._lastError = `Browser agent hit step limit before completing: ${result.message}`;
+        this.log(`Error: ${this._lastError}`);
+        this.log(`Debug session: ${result.debugUrl}`);
+        return "FAILURE" /* FAILURE */;
+      }
+      this.log(`Browser agent succeeded: ${result.message}`);
+      this.log(`Debug session: ${result.debugUrl}`);
+      return "SUCCESS" /* SUCCESS */;
+    } catch (error) {
+      this._lastError = error instanceof Error ? error.message : String(error);
+      this.log(`Browser agent failed: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+  }
+};
+
+// src/actions/claude-agent.ts
+var ClaudeAgent = class extends ActionNode {
+  prompt;
+  model;
+  systemPrompt;
+  allowedTools;
+  permissionMode;
+  maxTurns;
+  maxBudgetUsd;
+  agentCwd;
+  mcpServers;
+  agents;
+  outputKey;
+  constructor(config) {
+    super(config);
+    if (!config.prompt) {
+      throw new ConfigurationError("ClaudeAgent requires prompt");
+    }
+    if (!config.outputKey) {
+      throw new ConfigurationError("ClaudeAgent requires outputKey");
+    }
+    this.prompt = config.prompt;
+    this.model = config.model;
+    this.systemPrompt = config.systemPrompt;
+    this.allowedTools = config.allowedTools;
+    this.permissionMode = config.permissionMode ?? "default";
+    this.maxTurns = config.maxTurns ?? 50;
+    this.maxBudgetUsd = config.maxBudgetUsd;
+    this.agentCwd = config.cwd;
+    this.mcpServers = config.mcpServers;
+    this.agents = config.agents;
+    this.outputKey = config.outputKey;
+  }
+  async executeTick(context) {
+    if (!context.activities?.claudeAgent) {
+      this._lastError = "ClaudeAgent requires activities.claudeAgent to be configured. This activity handles autonomous agent execution via the Claude Agent SDK.";
+      this.log(`Error: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+    try {
+      const varCtx = {
+        blackboard: context.blackboard,
+        input: context.input,
+        testData: context.testData
+      };
+      const resolvedPrompt = resolveValue(this.prompt, varCtx);
+      const resolvedSystemPrompt = this.systemPrompt ? resolveValue(this.systemPrompt, varCtx) : void 0;
+      const resolvedModel = this.model ? resolveValue(this.model, varCtx) : void 0;
+      const resolvedCwd = this.agentCwd ? resolveValue(this.agentCwd, varCtx) : void 0;
+      const request = {
+        prompt: resolvedPrompt,
+        model: resolvedModel,
+        systemPrompt: resolvedSystemPrompt,
+        allowedTools: this.allowedTools,
+        permissionMode: this.permissionMode,
+        maxTurns: this.maxTurns,
+        maxBudgetUsd: this.maxBudgetUsd,
+        cwd: resolvedCwd,
+        mcpServers: this.mcpServers,
+        agents: this.agents
+      };
+      this.log(
+        `Claude agent: ${resolvedPrompt.substring(0, 80)}${resolvedPrompt.length > 80 ? "..." : ""}`
+      );
+      const result = await context.activities.claudeAgent(request);
+      context.blackboard.set(this.outputKey, result);
+      if (!result.success) {
+        this._lastError = `Claude agent failed: ${result.errors?.join(", ") || "unknown error"}`;
+        this.log(`Error: ${this._lastError}`);
+        return "FAILURE" /* FAILURE */;
+      }
+      this.log(
+        `Claude agent completed in ${result.numTurns} turns, $${result.totalCostUsd.toFixed(4)}, ${result.durationMs}ms`
+      );
+      return "SUCCESS" /* SUCCESS */;
+    } catch (error) {
+      this._lastError = error instanceof Error ? error.message : String(error);
+      this.log(`Claude agent failed: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+  }
+};
+
+// src/actions/github-action.ts
+var VALID_OPERATIONS = [
+  "createBranch",
+  "createPullRequest",
+  "getPullRequest",
+  "mergePullRequest",
+  "closePullRequest",
+  "createReview",
+  "listIssues",
+  "addLabels",
+  "createComment",
+  "createRelease"
+];
+var GitHubAction = class extends ActionNode {
+  operation;
+  repo;
+  params;
+  outputKey;
+  constructor(config) {
+    super(config);
+    if (!config.operation) {
+      throw new ConfigurationError("GitHubAction requires operation");
+    }
+    if (!VALID_OPERATIONS.includes(config.operation)) {
+      throw new ConfigurationError(
+        `GitHubAction: invalid operation "${config.operation}". Valid operations: ${VALID_OPERATIONS.join(", ")}`
+      );
+    }
+    if (!config.repo) {
+      throw new ConfigurationError("GitHubAction requires repo");
+    }
+    if (!config.outputKey) {
+      throw new ConfigurationError("GitHubAction requires outputKey");
+    }
+    this.operation = config.operation;
+    this.repo = config.repo;
+    this.params = config.params ?? {};
+    this.outputKey = config.outputKey;
+  }
+  async executeTick(context) {
+    if (!context.activities?.githubAction) {
+      this._lastError = "GitHubAction requires activities.githubAction to be configured. This activity handles GitHub API operations.";
+      this.log(`Error: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+    try {
+      const varCtx = {
+        blackboard: context.blackboard,
+        input: context.input,
+        testData: context.testData
+      };
+      const resolvedRepo = resolveValue(this.repo, varCtx);
+      const resolvedParams = {};
+      for (const [key, value] of Object.entries(this.params)) {
+        if (typeof value === "string") {
+          resolvedParams[key] = resolveValue(value, varCtx);
+        } else {
+          resolvedParams[key] = value;
+        }
+      }
+      const request = {
+        operation: this.operation,
+        repo: resolvedRepo,
+        params: resolvedParams
+      };
+      this.log(
+        `GitHub ${this.operation}: ${resolvedRepo}`
+      );
+      const result = await context.activities.githubAction(request);
+      context.blackboard.set(this.outputKey, result.data);
+      if (!result.success) {
+        this._lastError = `GitHub ${this.operation} failed`;
+        this.log(`Error: ${this._lastError}`);
+        return "FAILURE" /* FAILURE */;
+      }
+      this.log(`GitHub ${this.operation} completed successfully`);
+      return "SUCCESS" /* SUCCESS */;
+    } catch (error) {
+      this._lastError = error instanceof Error ? error.message : String(error);
+      this.log(`GitHub ${this.operation} failed: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+  }
+};
+
+// src/actions/human-task.ts
+var HumanTask = class extends ActionNode {
+  title;
+  description;
+  assignee;
+  assigneeRole;
+  a2ui;
+  timeoutMs;
+  onTimeout;
+  outputKey;
+  constructor(config) {
+    super(config);
+    if (!config.title) {
+      throw new ConfigurationError("HumanTask requires title");
+    }
+    if (!config.a2ui?.components || config.a2ui.components.length === 0) {
+      throw new ConfigurationError(
+        "HumanTask requires a2ui.components with at least one component"
+      );
+    }
+    this.title = config.title;
+    this.description = config.description;
+    this.assignee = config.assignee;
+    this.assigneeRole = config.assigneeRole;
+    this.a2ui = config.a2ui;
+    this.timeoutMs = config.timeoutMs ?? 864e5;
+    this.onTimeout = config.onTimeout ?? "expire";
+    this.outputKey = config.outputKey;
+  }
+  async executeTick(context) {
+    if (!context.activities?.createHumanTask) {
+      this._lastError = "HumanTask requires activities.createHumanTask to be configured. This activity creates a task record in the database.";
+      this.log(`Error: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+    if (!context.activities?.waitForHumanTask) {
+      this._lastError = "HumanTask requires activities.waitForHumanTask to be configured. This activity waits for the user to complete the task.";
+      this.log(`Error: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+    try {
+      const varCtx = {
+        blackboard: context.blackboard,
+        input: context.input,
+        testData: context.testData
+      };
+      const a2uiDataModel = {};
+      if (this.a2ui.dataBindings) {
+        for (const [a2uiPath, expression] of Object.entries(
+          this.a2ui.dataBindings
+        )) {
+          const resolved = resolveValue(expression, varCtx);
+          setNestedPath(a2uiDataModel, a2uiPath, resolved);
+        }
+      }
+      const resolvedTitle = resolveValue(this.title, varCtx);
+      const resolvedDescription = this.description ? resolveValue(this.description, varCtx) : void 0;
+      const resolvedAssignee = this.assignee ? resolveValue(this.assignee, varCtx) : void 0;
+      const tenantId = context.blackboard.get("__tenantId") || "";
+      const executionId = context.blackboard.get("__executionId") || context.workflowInfo?.workflowId || "";
+      const request = {
+        nodeId: this.id,
+        tenantId,
+        executionId,
+        title: resolvedTitle,
+        description: resolvedDescription,
+        assigneeEmail: resolvedAssignee,
+        assigneeRole: this.assigneeRole,
+        a2uiComponents: this.a2ui.components,
+        a2uiDataModel,
+        timeoutMs: this.timeoutMs,
+        onTimeout: this.onTimeout
+      };
+      this.log(
+        `Creating human task: "${resolvedTitle}" (timeout: ${this.timeoutMs}ms)`
+      );
+      const createResult = await context.activities.createHumanTask(request);
+      this.log(`Task created: ${createResult.taskId}`);
+      this.log(
+        `Waiting for human task ${createResult.taskId} on node ${this.id}`
+      );
+      const waitResult = await context.activities.waitForHumanTask({
+        taskId: createResult.taskId,
+        nodeId: this.id,
+        timeoutMs: this.timeoutMs,
+        onTimeout: this.onTimeout
+      });
+      const prefix = this.outputKey || this.id;
+      context.blackboard.set(`${prefix}.taskId`, createResult.taskId);
+      context.blackboard.set(`${prefix}.completed`, waitResult.completed);
+      context.blackboard.set(`${prefix}.decision`, waitResult.decision);
+      context.blackboard.set(
+        `${prefix}.submittedData`,
+        waitResult.submittedData
+      );
+      context.blackboard.set(`${prefix}.completedBy`, waitResult.completedBy);
+      context.blackboard.set(`${prefix}.timedOut`, waitResult.timedOut);
+      if (waitResult.timedOut) {
+        this._lastError = `Task timed out after ${this.timeoutMs}ms`;
+        this.log(`Task timed out, onTimeout=${this.onTimeout}`);
+        return this.onTimeout === "approve" ? "SUCCESS" /* SUCCESS */ : "FAILURE" /* FAILURE */;
+      }
+      this.log(
+        `Task completed: decision=${waitResult.decision}, completedBy=${waitResult.completedBy}`
+      );
+      return waitResult.completed ? "SUCCESS" /* SUCCESS */ : "FAILURE" /* FAILURE */;
+    } catch (error) {
+      this._lastError = error instanceof Error ? error.message : String(error);
+      this.log(`HumanTask failed: ${this._lastError}`);
+      return "FAILURE" /* FAILURE */;
+    }
+  }
+};
+function setNestedPath(obj, path2, value) {
+  const parts = path2.split("/").filter(Boolean);
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  if (parts.length > 0) {
+    const lastKey = parts[parts.length - 1];
+    current[lastKey] = 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" });
@@ -3942,12 +4986,23 @@ 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" });
   registry.register("GenerateFile", GenerateFile, { category: "action" });
   registry.register("HttpRequest", HttpRequest, { category: "action" });
   registry.register("CodeExecution", CodeExecution, { category: "action" });
+  registry.register("LLMChat", LLMChat, { category: "action" });
+  registry.register("BrowserAgent", BrowserAgent, { category: "action" });
+  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
@@ -4784,7 +5839,9 @@ export {
   AlwaysCondition,
   BaseNode,
   BehaviorTree,
+  BrowserAgent,
   CheckCondition,
+  ClaudeAgent,
   CodeExecution,
   CompositeNode,
   ConditionNode,
@@ -4801,10 +5858,14 @@ export {
   ForceFailure,
   ForceSuccess,
   GenerateFile,
+  GitHubAction,
   HttpRequest,
+  HumanTask,
   IntegrationAction,
   Invert,
   KeepRunningUntilFailure,
+  LLMChat,
+  LLMToolCall,
   LogMessage,
   MemoryDataStore,
   MemorySequence,
@@ -4831,14 +5892,19 @@ export {
   SemanticValidationError,
   Sequence,
   SequenceWithMemory,
+  SetVariable,
   SoftAssert,
+  StreamingSink,
   StructureValidationError,
   SubTree,
   SuccessNode,
   Timeout,
+  ToolExecutor,
+  ToolRouter,
   ValidationError,
   ValidationErrors,
   WaitAction,
+  WaitForSignal,
   While,
   YamlSyntaxError,
   clearPieceCache,