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

package/dist/index.cjs

@@ -34,7 +34,9 @@ __export(index_exports, {
   AlwaysCondition: () => AlwaysCondition,
   BaseNode: () => BaseNode,
   BehaviorTree: () => BehaviorTree,
+  BrowserAgent: () => BrowserAgent,
   CheckCondition: () => CheckCondition,
+  ClaudeAgent: () => ClaudeAgent,
   CodeExecution: () => CodeExecution,
   CompositeNode: () => CompositeNode,
   ConditionNode: () => ConditionNode,
@@ -51,10 +53,13 @@ __export(index_exports, {
   ForceFailure: () => ForceFailure,
   ForceSuccess: () => ForceSuccess,
   GenerateFile: () => GenerateFile,
+  GitHubAction: () => GitHubAction,
   HttpRequest: () => HttpRequest,
+  HumanTask: () => HumanTask,
   IntegrationAction: () => IntegrationAction,
   Invert: () => Invert,
   KeepRunningUntilFailure: () => KeepRunningUntilFailure,
+  LLMChat: () => LLMChat,
   LogMessage: () => LogMessage,
   MemoryDataStore: () => MemoryDataStore,
   MemorySequence: () => MemorySequence,
@@ -417,6 +422,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,
@@ -483,6 +501,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,
@@ -961,9 +992,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' }));
@@ -2545,8 +2576,63 @@ var memorySequenceConfigurationSchema = nodeConfigurationSchema;
 // src/composites/recovery.schema.ts
 var recoveryConfigurationSchema = nodeConfigurationSchema;
 
-// src/schemas/validation.ts
+// src/actions/llm-chat.schema.ts
 var import_zod3 = require("zod");
+var messageSchema = import_zod3.z.object({
+  role: import_zod3.z.enum(["system", "user", "assistant"]),
+  content: import_zod3.z.string().min(1, "Message content cannot be empty")
+});
+var llmChatSchema = createNodeSchema("LLMChat", {
+  provider: import_zod3.z.enum(["anthropic", "openai", "google", "ollama"]),
+  model: import_zod3.z.string().min(1, "Model is required"),
+  messages: import_zod3.z.array(messageSchema).min(1, "At least one message is required"),
+  systemPrompt: import_zod3.z.string().optional(),
+  temperature: import_zod3.z.number().min(0).max(2).optional(),
+  maxTokens: import_zod3.z.number().int().positive().optional(),
+  responseFormat: import_zod3.z.enum(["text", "json"]).optional().default("text"),
+  jsonSchema: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional(),
+  timeout: import_zod3.z.number().int().positive().optional().default(6e4),
+  baseUrl: import_zod3.z.string().url().optional(),
+  outputKey: import_zod3.z.string().min(1, "outputKey is required")
+});
+
+// src/actions/browser-agent.schema.ts
+var import_zod4 = require("zod");
+var browserAgentSchema = createNodeSchema("BrowserAgent", {
+  goal: import_zod4.z.string().min(1, "Goal is required"),
+  startUrl: import_zod4.z.string().optional(),
+  contextKey: import_zod4.z.string().optional(),
+  persistContext: import_zod4.z.boolean().optional().default(false),
+  timeout: import_zod4.z.number().int().positive().optional().default(6e4),
+  maxSteps: import_zod4.z.number().int().positive().optional().default(20),
+  llmProvider: import_zod4.z.enum(["anthropic", "openai", "google", "ollama"]).optional(),
+  llmModel: import_zod4.z.string().optional(),
+  outputKey: import_zod4.z.string().min(1, "outputKey is required")
+});
+
+// src/actions/human-task.schema.ts
+var import_zod5 = require("zod");
+var a2uiComponentSchema = import_zod5.z.object({
+  id: import_zod5.z.string().min(1, "Component ID cannot be empty"),
+  component: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()),
+  weight: import_zod5.z.number().optional()
+});
+var humanTaskSchema = createNodeSchema("HumanTask", {
+  title: import_zod5.z.string().min(1, "Title is required"),
+  description: import_zod5.z.string().optional(),
+  assignee: import_zod5.z.string().optional(),
+  assigneeRole: import_zod5.z.string().optional(),
+  a2ui: import_zod5.z.object({
+    components: import_zod5.z.array(a2uiComponentSchema).min(1, "At least one A2UI component is required"),
+    dataBindings: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.string()).optional()
+  }),
+  timeoutMs: import_zod5.z.number().int().positive().optional().default(864e5),
+  onTimeout: import_zod5.z.enum(["expire", "approve", "reject"]).optional().default("expire"),
+  outputKey: import_zod5.z.string().optional()
+});
+
+// src/schemas/validation.ts
+var import_zod6 = require("zod");
 function zodErrorToConfigurationError(error, nodeType, nodeId) {
   const nodeIdentifier = nodeId ? `${nodeType}:${nodeId}` : nodeType;
   const issues = error.issues.map((issue) => {
@@ -2562,7 +2648,7 @@ function validateConfiguration(schema, config, nodeType, nodeId) {
   try {
     return schema.parse(config);
   } catch (error) {
-    if (error instanceof import_zod3.z.ZodError) {
+    if (error instanceof import_zod6.z.ZodError) {
       throw zodErrorToConfigurationError(error, nodeType, nodeId);
     }
     throw error;
@@ -2581,14 +2667,14 @@ function safeValidateConfiguration(schema, config, nodeType, nodeId) {
 }
 
 // src/schemas/tree-definition.schema.ts
-var import_zod4 = require("zod");
-var treeDefSchemaObject = import_zod4.z.object({
-  type: import_zod4.z.string().min(1, "Node type is required"),
-  id: import_zod4.z.string().optional(),
-  name: import_zod4.z.string().optional(),
-  props: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional(),
-  children: import_zod4.z.array(
-    import_zod4.z.lazy(() => treeDefinitionSchema)
+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)
   ).optional()
 });
 var treeDefinitionSchema = treeDefSchemaObject;
@@ -2667,6 +2753,9 @@ 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);
   }
   /**
    * Register a validation schema for a node type
@@ -4020,6 +4109,481 @@ 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/registry-utils.ts
 function registerStandardNodes(registry) {
   registry.register("Sequence", Sequence, { category: "composite" });
@@ -4079,6 +4643,11 @@ function registerStandardNodes(registry) {
   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" });
 }
 
 // src/data-store/memory-store.ts
@@ -4916,7 +5485,9 @@ function createObservabilitySinkHandler(config = {}) {
   AlwaysCondition,
   BaseNode,
   BehaviorTree,
+  BrowserAgent,
   CheckCondition,
+  ClaudeAgent,
   CodeExecution,
   CompositeNode,
   ConditionNode,
@@ -4933,10 +5504,13 @@ function createObservabilitySinkHandler(config = {}) {
   ForceFailure,
   ForceSuccess,
   GenerateFile,
+  GitHubAction,
   HttpRequest,
+  HumanTask,
   IntegrationAction,
   Invert,
   KeepRunningUntilFailure,
+  LLMChat,
   LogMessage,
   MemoryDataStore,
   MemorySequence,