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

package/dist/index.d.ts

@@ -1,520 +1,8 @@
+import { T as TreeNode, N as NodeStatus, a as NodeConfiguration, b as NodeEventEmitter, c as TemporalContext, P as PortDefinition, W as WorkflowArgs, d as WorkflowResult, I as IScopedBlackboard, e as NodeConstructor, f as NodeMetadata, g as TokenProvider, h as PieceActivityRequest, i as ParseFileRequest, L as LLMProvider, M as MessageRole, C as ClaudeAgentMcpServerConfig, j as ClaudeAgentSubagent, G as GitHubOperation, A as A2UIComponent, k as AgentToolDefinition } from './types-BJPlUisg.js';
+export { a6 as AgentContentBlock, a9 as AgentLoopTurnRequest, aa as AgentLoopTurnResult, a7 as AgentMessage, a8 as AgentToolCall, Y as BrowserAgentRequest, Z as BrowserAgentResult, B as BtreeActivities, _ as ClaudeAgentRequest, $ as ClaudeAgentResult, t as CodeExecutionRequest, u as CodeExecutionResult, a2 as CreateHumanTaskRequest, a3 as CreateHumanTaskResult, D as DataRef, K as DeleteFileRequest, O as DeleteFileResult, F as DownloadFileRequest, J as DownloadFileResult, ab as ExecuteAgentToolRequest, ac as ExecuteAgentToolResult, Q as FileExistsRequest, R as FileExistsResult, q as GenerateFileRequest, r as GenerateFileResult, ad as GenericSignalPayload, a0 as GitHubActionRequest, a1 as GitHubActionResult, H as HttpRequestActivity, s as HttpResponseActivity, l as ITreeRegistry, V as LLMChatRequest, X as LLMChatResult, S as LLMMessage, w as LogEventData, x as NodeEvent, y as NodeEventCallback, v as NodeEventType, p as ParseFileResult, m as PieceAuth, n as PythonScriptRequest, o as PythonScriptResult, z as TickContext, U as UploadFileRequest, E as UploadFileResult, a4 as WaitForHumanTaskRequest, a5 as WaitForHumanTaskResult, ae as WaitForSignalRequest, af as WaitForSignalResult } from './types-BJPlUisg.js';
 import { z } from 'zod';
 import { Sinks } from '@temporalio/workflow';
 
-/**
- * Event system for observing behavior tree execution
- * Enables external systems (debuggers, monitors, agents) to track execution in real-time
- */
-/**
- * Types of events emitted by nodes during execution
- */
-declare enum NodeEventType {
-    TICK_START = "tick_start",
-    TICK_END = "tick_end",
-    STATUS_CHANGE = "status_change",
-    ERROR = "error",
-    HALT = "halt",
-    RESET = "reset",
-    LOG = "log"
-}
-/**
- * Data for LOG events emitted by LogMessage nodes
- */
-interface LogEventData {
-    level: "info" | "warn" | "error" | "debug";
-    message: string;
-}
-/**
- * Event emitted by a node during execution
- */
-interface NodeEvent<TData> {
-    type: NodeEventType;
-    nodeId: string;
-    nodeName: string;
-    nodeType: string;
-    timestamp: number;
-    /** Tree path (e.g., "/0/1/2") - set by tree execution */
-    nodePath?: string;
-    data?: TData;
-}
-/**
- * Callback function for node events
- */
-type NodeEventCallback<TData> = (event: NodeEvent<TData>) => void;
-/**
- * Event emitter for behavior tree nodes
- * Supports subscribing to specific event types and emitting events
- */
-declare class NodeEventEmitter {
-    private listeners;
-    private allListeners;
-    /**
-     * Subscribe to a specific event type
-     * @param type - The event type to listen for
-     * @param callback - Function to call when event occurs
-     */
-    on<TData>(type: NodeEventType, callback: NodeEventCallback<TData>): void;
-    /**
-     * Subscribe to all event types
-     * @param callback - Function to call for any event
-     */
-    onAll<TData>(callback: NodeEventCallback<TData>): void;
-    /**
-     * Unsubscribe from a specific event type
-     * @param type - The event type to stop listening for
-     * @param callback - The callback to remove
-     */
-    off<TData>(type: NodeEventType, callback: NodeEventCallback<TData>): void;
-    /**
-     * Unsubscribe from all events
-     * @param callback - The callback to remove
-     */
-    offAll<TData>(callback: NodeEventCallback<TData>): void;
-    /**
-     * Emit an event to all registered listeners
-     * Errors in callbacks are caught and logged to prevent breaking execution
-     * @param event - The event to emit
-     */
-    emit<TData>(event: NodeEvent<TData>): void;
-    /**
-     * Remove all listeners
-     */
-    clear(): void;
-    /**
-     * Get count of listeners for a specific type
-     * @param type - The event type to check
-     * @returns Number of listeners
-     */
-    listenerCount(type: NodeEventType): number;
-    /**
-     * Get count of "all events" listeners
-     * @returns Number of listeners
-     */
-    allListenerCount(): number;
-    /**
-     * Check if there are any listeners
-     * @returns True if any listeners are registered
-     */
-    hasListeners(): boolean;
-}
-
-/**
- * Core types for the Behavior Tree implementation
- * Inspired by BehaviorTree.CPP
- */
-/**
- * Status of a node after tick execution
- */
-declare enum NodeStatus {
-    SUCCESS = "SUCCESS",
-    FAILURE = "FAILURE",
-    RUNNING = "RUNNING",
-    IDLE = "IDLE"
-}
-/**
- * Base configuration for all nodes
- */
-interface NodeConfiguration {
-    id: string;
-    name?: string;
-    [key: string]: unknown;
-}
-/**
- * Context passed during tick execution
- */
-interface TickContext {
-    blackboard: IScopedBlackboard;
-    treeRegistry: ITreeRegistry;
-    signal?: AbortSignal;
-    deltaTime?: number;
-    timestamp: number;
-    testData?: Map<string, unknown>;
-    /**
-     * Immutable workflow input parameters
-     * Accessible via ${input.key} syntax in variable resolution
-     * These are passed when the workflow starts and should not be modified
-     */
-    input?: Readonly<Record<string, unknown>>;
-    sessionId?: string;
-    eventEmitter?: NodeEventEmitter;
-}
-/**
- * Token provider function type for OAuth/API key authentication
- */
-type TokenProvider = (context: TemporalContext, provider: string, connectionId?: string) => Promise<PieceAuth>;
-/**
- * Extended context for Temporal workflow execution
- * Replaces EffectTickContext for Temporal-native execution
- */
-interface TemporalContext extends TickContext {
-    workflowInfo?: {
-        workflowId: string;
-        runId: string;
-        namespace: string;
-    };
-    /**
-     * Activity functions for I/O operations
-     * When provided, I/O nodes use these instead of inline execution
-     * Controlplane creates these via proxyActivities() and passes to context
-     */
-    activities?: BtreeActivities;
-    /**
-     * Token provider for IntegrationAction authentication
-     * Returns OAuth tokens or API keys for third-party services
-     */
-    tokenProvider?: TokenProvider;
-}
-/**
- * Activity capabilities that can be provided to btree
- * Controlplane creates these via proxyActivities() and passes to context
- */
-interface BtreeActivities {
-    /** Execute an Active Pieces action (Google Sheets, Slack, etc.) */
-    executePieceAction: (request: PieceActivityRequest) => Promise<unknown>;
-    /** Execute Python code via cross-language activity */
-    executePythonScript?: (request: PythonScriptRequest) => Promise<PythonScriptResult>;
-    /** Parse CSV/Excel file into structured data */
-    parseFile?: (request: ParseFileRequest) => Promise<ParseFileResult>;
-    /** Generate CSV/Excel file from data */
-    generateFile?: (request: GenerateFileRequest) => Promise<GenerateFileResult>;
-    /** Make HTTP request (for nodes that don't use Active Pieces) */
-    fetchUrl?: (request: HttpRequestActivity) => Promise<HttpResponseActivity>;
-    /** Execute code in sandbox (Microsandbox) - supports JavaScript and Python */
-    executeCode?: (request: CodeExecutionRequest) => Promise<CodeExecutionResult>;
-    /** Upload file to storage, returns DataRef */
-    uploadFile?: (request: UploadFileRequest) => Promise<UploadFileResult>;
-    /** Download file from storage */
-    downloadFile?: (request: DownloadFileRequest) => Promise<DownloadFileResult>;
-    /** Delete file from storage */
-    deleteFile?: (request: DeleteFileRequest) => Promise<DeleteFileResult>;
-    /** Check if file exists in storage */
-    fileExists?: (request: FileExistsRequest) => Promise<FileExistsResult>;
-}
-/**
- * Authentication credentials for a piece
- */
-type PieceAuth = {
-    access_token: string;
-    refresh_token?: string;
-} | {
-    api_key: string;
-} | Record<string, unknown>;
-interface PieceActivityRequest {
-    provider: string;
-    action: string;
-    inputs: Record<string, unknown>;
-    auth: PieceAuth;
-}
-interface PythonScriptRequest {
-    /** Python code to execute */
-    code: string;
-    /** Blackboard snapshot (serializable) */
-    blackboard: Record<string, unknown>;
-    /** Workflow input (read-only) */
-    input?: Record<string, unknown>;
-    /** Allowed environment variables */
-    env?: Record<string, string>;
-    /** Execution timeout in ms */
-    timeout?: number;
-}
-interface PythonScriptResult {
-    /** Modified blackboard values */
-    blackboard: Record<string, unknown>;
-    /** Stdout from Python execution */
-    stdout?: string;
-    /** Stderr from Python execution */
-    stderr?: string;
-}
-interface ParseFileRequest {
-    /** File path or URL */
-    file: string;
-    /** File format (auto-detect if not specified) */
-    format?: "csv" | "xlsx" | "xls" | "auto";
-    /** Sheet name for Excel (default: first sheet) */
-    sheetName?: string;
-    /** Column mapping { "Original Name": "normalizedName" } */
-    columnMapping?: Record<string, string>;
-    /** Parse options */
-    options?: {
-        skipRows?: number;
-        trim?: boolean;
-        emptyAsNull?: boolean;
-        dateColumns?: string[];
-        dateFormat?: string;
-    };
-}
-interface ParseFileResult {
-    /** Parsed data rows */
-    data: Record<string, unknown>[];
-    /** Number of rows parsed */
-    rowCount: number;
-    /** Column names detected */
-    columns: string[];
-}
-interface GenerateFileRequest {
-    /** Output format */
-    format: "csv" | "xlsx" | "json";
-    /** Data to write */
-    data: Record<string, unknown>[];
-    /** Column definitions */
-    columns?: Array<{
-        header: string;
-        key: string;
-        width?: number;
-    }>;
-    /** Output filename */
-    filename: string;
-    /** Storage type */
-    storage: "temp" | "persistent";
-}
-interface GenerateFileResult {
-    /** Generated filename */
-    filename: string;
-    /** MIME type */
-    contentType: string;
-    /** File size in bytes */
-    size: number;
-    /** File path or storage key */
-    path: string;
-    /** Pre-signed download URL (if persistent) */
-    url?: string;
-}
-interface HttpRequestActivity {
-    url: string;
-    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
-    headers?: Record<string, string>;
-    body?: unknown;
-    timeout?: number;
-}
-interface HttpResponseActivity {
-    status: number;
-    headers: Record<string, string>;
-    data: unknown;
-}
-interface UploadFileRequest {
-    /** Base64-encoded file content */
-    fileBytes: string;
-    /** Target filename */
-    filename: string;
-    /** MIME type */
-    contentType?: string;
-    /** Workflow ID for organizing storage */
-    workflowId?: string;
-}
-interface UploadFileResult {
-    /** Reference to stored file */
-    dataRef: DataRef$1;
-    /** Uploaded filename */
-    filename: string;
-    /** File size in bytes */
-    sizeBytes: number;
-}
-interface DownloadFileRequest {
-    /** Reference to file in storage */
-    dataRef: DataRef$1;
-}
-interface DownloadFileResult {
-    /** Base64-encoded file content */
-    fileBytes: string;
-    /** File size in bytes */
-    sizeBytes: number;
-}
-interface DeleteFileRequest {
-    /** Reference to file in storage */
-    dataRef: DataRef$1;
-}
-interface DeleteFileResult {
-    /** Whether deletion was successful */
-    deleted: boolean;
-    /** Key of deleted file */
-    key: string;
-}
-interface FileExistsRequest {
-    /** Reference to file in storage */
-    dataRef: DataRef$1;
-}
-interface FileExistsResult {
-    /** Whether file exists */
-    exists: boolean;
-    /** Key checked */
-    key: string;
-}
-/**
- * Reference to data stored in a DataStore
- * Import from data-store module for full type, this is a lightweight re-export
- */
-interface DataRef$1 {
-    store: "gcs" | "s3" | "redis" | "memory";
-    key: string;
-    sizeBytes?: number;
-    expiresAt?: number;
-}
-/**
- * Request for code execution in a sandboxed environment
- */
-interface CodeExecutionRequest {
-    /** Code to execute */
-    code: string;
-    /** Programming language */
-    language: "javascript" | "python";
-    /** References to large data stored in DataStore */
-    dataRefs?: Record<string, DataRef$1>;
-    /** Inline context data (small values) */
-    context?: Record<string, unknown>;
-    /** Workflow input data (read-only) */
-    input?: Record<string, unknown>;
-    /** Execution timeout in milliseconds */
-    timeout?: number;
-    /** Python packages to install before execution */
-    packages?: string[];
-    /** Associated workflow ID for data storage */
-    workflowId?: string;
-}
-/**
- * Result from code execution
- */
-interface CodeExecutionResult {
-    /** Small values returned inline */
-    values: Record<string, unknown>;
-    /** Large values stored in DataStore (returns refs) */
-    dataRefs: Record<string, DataRef$1>;
-    /** Console/stdout output from execution */
-    logs: string[];
-    /** Total execution time in milliseconds */
-    executionTimeMs: number;
-}
-/**
- * Port definition for typed inputs/outputs
- */
-interface PortDefinition {
-    name: string;
-    type: "input" | "output" | "inout";
-    description?: string;
-    defaultValue?: unknown;
-    required?: boolean;
-}
-/**
- * Base interface for all tree nodes
- */
-interface TreeNode {
-    readonly id: string;
-    readonly name: string;
-    readonly type: string;
-    tick(context: TemporalContext): Promise<NodeStatus>;
-    halt(): void;
-    reset(): void;
-    clone(): TreeNode;
-    providedPorts?(): PortDefinition[];
-    status(): NodeStatus;
-    lastError?: string;
-    parent?: TreeNode;
-    children?: TreeNode[];
-}
-/**
- * Constructor type for node factories
- */
-type NodeConstructor<T extends TreeNode = TreeNode> = new (config: NodeConfiguration) => T;
-/**
- * Node metadata for registry
- */
-interface NodeMetadata {
-    type: string;
-    category: "action" | "condition" | "decorator" | "composite" | "subtree";
-    description?: string;
-    ports?: PortDefinition[];
-}
-/**
- * Interface for tree registry (session-scoped)
- * Used by nodes like StepGroup and LocateElement to lookup behavior trees
- */
-interface ITreeRegistry {
-    hasTree(id: string): boolean;
-    cloneTree(id: string): {
-        getRoot(): TreeNode;
-    };
-    getAllTreeIds(): string[];
-    registerTree(id: string, tree: {
-        getRoot(): TreeNode;
-        clone(): {
-            getRoot(): TreeNode;
-        };
-    }, sourceFile: string): void;
-    getTree(id: string): {
-        getRoot(): TreeNode;
-        clone(): {
-            getRoot(): TreeNode;
-        };
-    } | undefined;
-    getTreeSourceFile(id: string): string | undefined;
-    getTreesForFile(filePath: string): Map<string, {
-        getRoot(): TreeNode;
-        clone(): {
-            getRoot(): TreeNode;
-        };
-    }>;
-}
-/**
- * Interface for scoped blackboard
- */
-interface IScopedBlackboard {
-    get(key: string): unknown;
-    set(key: string, value: unknown): void;
-    has(key: string): boolean;
-    delete(key: string): void;
-    clear(): void;
-    createScope(name: string): IScopedBlackboard;
-    getParentScope(): IScopedBlackboard | null;
-    getScopeName(): string;
-    getFullScopePath(): string;
-    getPort<T>(key: string, defaultValue?: T): T;
-    setPort<T>(key: string, value: T): void;
-    keys(): string[];
-    entries(): [string, unknown][];
-    toJSON(): Record<string, unknown>;
-    clone(): IScopedBlackboard;
-}
-/**
- * Arguments passed to a BehaviorTree workflow
- */
-interface WorkflowArgs {
-    /**
-     * Input data to initialize the blackboard
-     */
-    input?: Record<string, unknown>;
-    /**
-     * Tree registry for looking up subtrees
-     */
-    treeRegistry: ITreeRegistry;
-    /**
-     * Optional session ID
-     */
-    sessionId?: string;
-    /**
-     * Activity functions for I/O operations (optional)
-     * When provided, nodes that support activities will use them instead of inline execution
-     * Controlplane creates these via proxyActivities() and passes them here
-     */
-    activities?: BtreeActivities;
-    /**
-     * Token provider for IntegrationAction authentication (optional)
-     * Returns OAuth tokens or API keys for third-party services
-     */
-    tokenProvider?: TokenProvider;
-}
-/**
- * Result returned from a BehaviorTree workflow
- */
-interface WorkflowResult {
-    /**
-     * Final status of the tree
-     */
-    status: NodeStatus;
-    /**
-     * Final blackboard state
-     */
-    output: Record<string, unknown>;
-}
-
 /**
  * Abstract base class for all tree nodes
  */
@@ -738,9 +226,9 @@ declare 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' }));
@@ -1253,6 +741,55 @@ declare class SoftAssert extends DecoratorNode {
     protected onReset(): void;
 }
 
+/**
+ * StreamingSink Decorator
+ *
+ * Injects a streaming channel ID into the blackboard for child LLM calls.
+ * LLMToolCall reads `__streamChannelId` and passes it to the activity,
+ * enabling token-level streaming to a WebSocket or SSE channel.
+ *
+ * The decorator saves and restores the previous value, making it safe
+ * to nest (inner StreamingSink overrides, then restores outer channel).
+ */
+
+/**
+ * Configuration for StreamingSink decorator
+ */
+interface StreamingSinkConfig extends NodeConfiguration {
+    /** Explicit channel ID */
+    channelId?: string;
+    /** OR: blackboard key to read channel ID from */
+    channelKey?: string;
+}
+/**
+ * StreamingSink Decorator
+ *
+ * Sets `__streamChannelId` on the blackboard before ticking the child,
+ * then restores the previous value after.
+ *
+ * @example YAML
+ * ```yaml
+ * type: StreamingSink
+ * id: stream-to-client
+ * props:
+ *   channelId: "ws-session-abc"
+ * children:
+ *   - type: LLMToolCall
+ *     id: call-llm
+ *     props:
+ *       provider: anthropic
+ *       model: claude-sonnet-4-20250514
+ *       messagesKey: msgs
+ *       outputKey: response
+ * ```
+ */
+declare class StreamingSink extends DecoratorNode {
+    private channelId?;
+    private channelKey?;
+    constructor(config: StreamingSinkConfig);
+    executeTick(context: TemporalContext): Promise<NodeStatus>;
+}
+
 /**
  * Timeout decorator node
  * Fails if the child doesn't complete within a specified time
@@ -1421,7 +958,7 @@ declare class Registry {
  *
  * @example
  * ```typescript
- * import { Registry, registerStandardNodes } from '@wayfarer-ai/btree';
+ * import { Registry, registerStandardNodes } from '@q1k-oss/behaviour-tree-workflows';
  *
  * const registry = new Registry();
  * registerStandardNodes(registry);
@@ -1487,7 +1024,9 @@ declare class MockAction extends ActionNode {
     protected onHalt(): void;
 }
 /**
- * Condition that checks if a blackboard value meets a criteria
+ * Condition that checks if a blackboard value meets a criteria.
+ * Supports dotted path keys (e.g., "llmResponse.stopReason") to access
+ * nested properties of blackboard values.
  */
 declare class CheckCondition extends ConditionNode {
     private key;
@@ -1498,6 +1037,11 @@ declare class CheckCondition extends ConditionNode {
         operator?: string;
         value: unknown;
     });
+    /**
+     * Resolve a potentially dotted key from the blackboard.
+     * Tries exact key first (backward compatible), then dotted path traversal.
+     */
+    private resolveBlackboardValue;
     executeTick(context: TemporalContext): Promise<NodeStatus>;
 }
 /**
@@ -1738,6 +1282,54 @@ declare class RegexExtract extends ActionNode {
     executeTick(context: TemporalContext): Promise<NodeStatus>;
 }
 
+/**
+ * SetVariable Node
+ *
+ * Simple utility node that sets a blackboard key to a value.
+ * Supports variable resolution in both key and value.
+ * Primary use case: controlling While loop conditions in agent loops.
+ */
+
+/**
+ * Configuration for SetVariable node
+ */
+interface SetVariableConfig extends NodeConfiguration {
+    /** Blackboard key to set (supports ${bb.x} / ${input.x} resolution) */
+    key: string;
+    /** Value to set (supports variable resolution) */
+    value: unknown;
+}
+/**
+ * SetVariable Node
+ *
+ * Sets a blackboard key to a resolved value. Used for loop control,
+ * intermediate state management, and data transformation.
+ *
+ * @example YAML - Loop control
+ * ```yaml
+ * type: SetVariable
+ * id: init-loop
+ * props:
+ *   key: agentLooping
+ *   value: true
+ * ```
+ *
+ * @example YAML - Dynamic value
+ * ```yaml
+ * type: SetVariable
+ * id: copy-result
+ * props:
+ *   key: finalAnswer
+ *   value: "${bb.llmResponse.content}"
+ * ```
+ */
+declare class SetVariable extends ActionNode {
+    private key;
+    private value;
+    constructor(config: SetVariableConfig);
+    protected executeTick(context: TemporalContext): Promise<NodeStatus>;
+}
+
 /**
  * Unified Variable Resolver
  *
@@ -2426,7 +2018,7 @@ declare const schemaRegistry: SchemaRegistry;
 
 /**
  * Template Loader
- * Load YAML template files from a directory and register them in the btree Registry.
+ * Load YAML template files from a directory and register them in the behaviour-tree Registry.
  * Templates can then be referenced by SubTree nodes using their template ID.
  */
 
@@ -2596,7 +2188,7 @@ declare const envTokenProvider: TokenProvider;
  * Dynamically executes Active Pieces actions
  *
  * Active Pieces is an open-source automation platform with 440+ connectors.
- * This module wraps their npm packages for use in btree workflows.
+ * This module wraps their npm packages for use in behaviour-tree workflows.
  *
  * @see https://activepieces.com/docs
  */
@@ -3038,6 +2630,743 @@ declare class CodeExecution extends ActionNode {
     protected executeTick(context: TemporalContext): Promise<NodeStatus>;
 }
 
+/**
+ * LLMChat Node
+ *
+ * Executes LLM chat completion via a Temporal activity.
+ * This node requires the `llmChat` activity to be configured in the context -
+ * it does not support standalone/inline execution because LLM API calls require
+ * capabilities outside the workflow sandbox.
+ *
+ * Features:
+ * - Multi-provider support (Anthropic, OpenAI, Google, Ollama)
+ * - Variable resolution in messages and system prompt
+ * - JSON response format with schema validation
+ * - Token usage tracking
+ * - Result stored in blackboard
+ */
+
+/**
+ * Configuration for LLMChat node
+ */
+interface LLMChatConfig extends NodeConfiguration {
+    /** LLM provider: anthropic, openai, google, ollama */
+    provider: LLMProvider;
+    /** Model identifier (supports ${bb.model} resolution) */
+    model: string;
+    /** Conversation messages (supports variable resolution in content) */
+    messages: Array<{
+        role: MessageRole;
+        content: string;
+    }>;
+    /** Optional system prompt (supports variable resolution) */
+    systemPrompt?: string;
+    /** Sampling temperature (0-2) */
+    temperature?: number;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Response format */
+    responseFormat?: "text" | "json";
+    /** JSON schema for structured output */
+    jsonSchema?: Record<string, unknown>;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Ollama base URL for local instance */
+    baseUrl?: string;
+    /** Output key on blackboard for response */
+    outputKey: string;
+}
+/**
+ * LLMChat Node
+ *
+ * Executes LLM chat completion via a Temporal activity and stores the response in blackboard.
+ * Requires the `llmChat` activity to be configured.
+ *
+ * @example YAML - Basic Usage
+ * ```yaml
+ * type: LLMChat
+ * id: summarize
+ * props:
+ *   provider: anthropic
+ *   model: claude-sonnet-4-20250514
+ *   systemPrompt: "You are a helpful assistant."
+ *   messages:
+ *     - role: user
+ *       content: "Summarize: ${bb.documentText}"
+ *   temperature: 0.7
+ *   maxTokens: 1000
+ *   outputKey: summary
+ * ```
+ *
+ * @example YAML - JSON Response
+ * ```yaml
+ * type: LLMChat
+ * id: extract-entities
+ * props:
+ *   provider: openai
+ *   model: gpt-4
+ *   messages:
+ *     - role: user
+ *       content: "Extract entities from: ${bb.text}"
+ *   responseFormat: json
+ *   jsonSchema:
+ *     type: object
+ *     properties:
+ *       people: { type: array, items: { type: string } }
+ *       organizations: { type: array, items: { type: string } }
+ *   outputKey: entities
+ * ```
+ */
+declare class LLMChat extends ActionNode {
+    private provider;
+    private model;
+    private messages;
+    private systemPrompt?;
+    private temperature?;
+    private maxTokens?;
+    private responseFormat;
+    private jsonSchema?;
+    private timeout?;
+    private baseUrl?;
+    private outputKey;
+    constructor(config: LLMChatConfig);
+    protected executeTick(context: TemporalContext): Promise<NodeStatus>;
+}
+
+/**
+ * BrowserAgent Node
+ *
+ * Executes autonomous browser agent via Browserbase + Stagehand.
+ * This node requires the `browserAgent` activity to be configured in the context -
+ * it does not support standalone/inline execution because browser automation requires
+ * capabilities outside the workflow sandbox.
+ *
+ * Features:
+ * - Goal-directed autonomous web navigation
+ * - Browserbase Contexts for session persistence (cookies, auth, cache)
+ * - Session recording via Browserbase for debugging/audit
+ * - Variable resolution in goal and startUrl
+ * - Result stored in blackboard with debugUrl for session replay
+ */
+
+/**
+ * Configuration for BrowserAgent node
+ */
+interface BrowserAgentConfig extends NodeConfiguration {
+    /** Goal for the agent to achieve (supports variable resolution) */
+    goal: string;
+    /** Starting URL (optional, supports variable resolution) */
+    startUrl?: string;
+    /** Blackboard key to store/retrieve contextId */
+    contextKey?: string;
+    /** Whether to persist context changes (cookies, auth, cache) */
+    persistContext?: boolean;
+    /** Timeout for entire agent execution (ms) */
+    timeout?: number;
+    /** Max steps/actions the agent can take */
+    maxSteps?: number;
+    /** LLM provider for Stagehand agent */
+    llmProvider?: LLMProvider;
+    /** LLM model for Stagehand agent */
+    llmModel?: string;
+    /** Output key on blackboard for result */
+    outputKey: string;
+}
+/**
+ * BrowserAgent Node
+ *
+ * Executes autonomous browser agent via Browserbase + Stagehand and stores the result in blackboard.
+ * Requires the `browserAgent` activity to be configured.
+ *
+ * @example YAML - Basic Usage
+ * ```yaml
+ * type: BrowserAgent
+ * id: search
+ * props:
+ *   goal: "Search for weather in NYC and extract the temperature"
+ *   startUrl: "https://google.com"
+ *   timeout: 60000
+ *   maxSteps: 15
+ *   outputKey: searchResult
+ * ```
+ *
+ * @example YAML - Multi-Step with Context Persistence
+ * ```yaml
+ * type: Sequence
+ * id: authenticated-scrape
+ * children:
+ *   - type: BrowserAgent
+ *     id: login
+ *     props:
+ *       goal: "Login with username ${input.user} and password ${input.pass}"
+ *       startUrl: "${input.loginUrl}"
+ *       contextKey: browserContext
+ *       persistContext: true
+ *       outputKey: loginResult
+ *
+ *   - type: BrowserAgent
+ *     id: scrape
+ *     props:
+ *       goal: "Navigate to dashboard and extract all data as JSON"
+ *       contextKey: browserContext
+ *       outputKey: scrapeResult
+ * ```
+ */
+declare class BrowserAgent extends ActionNode {
+    private goal;
+    private startUrl?;
+    private contextKey?;
+    private persistContext;
+    private timeout?;
+    private maxSteps?;
+    private llmProvider?;
+    private llmModel?;
+    private outputKey;
+    constructor(config: BrowserAgentConfig);
+    protected executeTick(context: TemporalContext): Promise<NodeStatus>;
+}
+
+/**
+ * ClaudeAgent Node
+ *
+ * Executes an autonomous Claude agent via a Temporal activity.
+ * This node requires the `claudeAgent` activity to be configured in the context -
+ * it does not support standalone/inline execution because agent execution requires
+ * capabilities outside the workflow sandbox.
+ *
+ * Features:
+ * - Goal-driven autonomous coding agent (powered by Claude Agent SDK)
+ * - Configurable tools, permissions, and cost limits
+ * - MCP server integration for external tools
+ * - Subagent support for delegating specialized tasks
+ * - Variable resolution in prompt, systemPrompt, model, and cwd
+ * - Session ID returned for resuming/continuing agent conversations
+ * - Result stored in blackboard
+ */
+
+/**
+ * Configuration for ClaudeAgent node
+ */
+interface ClaudeAgentConfig extends NodeConfiguration {
+    /** Task prompt for the agent (supports variable resolution) */
+    prompt: string;
+    /** Model to use, e.g. "claude-sonnet-4-5-20250929" (supports variable resolution) */
+    model?: string;
+    /** System prompt for agent behavior (supports variable resolution) */
+    systemPrompt?: string;
+    /** Tools the agent can use (e.g., ["Read", "Write", "Edit", "Bash"]) */
+    allowedTools?: string[];
+    /** Permission mode: default, acceptEdits, bypassPermissions */
+    permissionMode?: "default" | "acceptEdits" | "bypassPermissions";
+    /** Maximum conversation turns */
+    maxTurns?: number;
+    /** Maximum budget in USD */
+    maxBudgetUsd?: number;
+    /** Working directory for the agent (supports variable resolution) */
+    cwd?: string;
+    /** MCP server configurations */
+    mcpServers?: Record<string, ClaudeAgentMcpServerConfig>;
+    /** Subagent definitions */
+    agents?: Record<string, ClaudeAgentSubagent>;
+    /** Output key on blackboard for result */
+    outputKey: string;
+}
+/**
+ * ClaudeAgent Node
+ *
+ * Executes an autonomous Claude agent via the Claude Agent SDK and stores
+ * the result in blackboard. Requires the `claudeAgent` activity to be configured.
+ *
+ * @example YAML - Basic coding task
+ * ```yaml
+ * type: ClaudeAgent
+ * id: implement-feature
+ * props:
+ *   prompt: "Add unit tests for the auth module"
+ *   allowedTools: [Read, Write, Edit, Bash, Glob, Grep]
+ *   permissionMode: acceptEdits
+ *   outputKey: agentResult
+ * ```
+ *
+ * @example YAML - Dev workflow with PR creation
+ * ```yaml
+ * type: ClaudeAgent
+ * id: dev-task
+ * props:
+ *   prompt: "${bb.taskDescription}"
+ *   systemPrompt: |
+ *     You are working on @q1k-oss/behaviour-tree-workflows.
+ *     Read CLAUDE.md for project conventions.
+ *     Create a branch, implement changes, commit, push, and create a PR.
+ *   allowedTools: [Read, Write, Edit, Bash, Glob, Grep]
+ *   permissionMode: acceptEdits
+ *   maxTurns: 100
+ *   maxBudgetUsd: 10.0
+ *   outputKey: agentResult
+ * ```
+ */
+declare class ClaudeAgent extends ActionNode {
+    private prompt;
+    private model?;
+    private systemPrompt?;
+    private allowedTools?;
+    private permissionMode;
+    private maxTurns;
+    private maxBudgetUsd?;
+    private agentCwd?;
+    private mcpServers?;
+    private agents?;
+    private outputKey;
+    constructor(config: ClaudeAgentConfig);
+    protected executeTick(context: TemporalContext): Promise<NodeStatus>;
+}
+
+/**
+ * GitHubAction Node
+ *
+ * Executes deterministic GitHub operations via a Temporal activity.
+ * This node requires the `githubAction` activity to be configured in the context -
+ * it does not support standalone/inline execution because GitHub API access requires
+ * capabilities outside the workflow sandbox.
+ *
+ * Features:
+ * - 10 supported operations (branches, PRs, reviews, issues, releases)
+ * - Variable resolution in repo and params
+ * - Auth handled at activity layer — no tokens in YAML
+ * - Result stored in blackboard
+ *
+ * @example YAML - Create a PR
+ * ```yaml
+ * type: GitHubAction
+ * id: create-pr
+ * props:
+ *   operation: createPullRequest
+ *   repo: "${input.repo}"
+ *   params:
+ *     title: "feat: new feature"
+ *     body: "Description"
+ *     head: "feat/branch"
+ *     base: "main"
+ *   outputKey: prResult
+ * ```
+ */
+
+/**
+ * Configuration for GitHubAction node
+ */
+interface GitHubActionConfig extends NodeConfiguration {
+    /** The GitHub operation to perform */
+    operation: GitHubOperation;
+    /** Repository in "owner/repo" format (supports variable resolution) */
+    repo: string;
+    /** Operation-specific parameters (string values support variable resolution) */
+    params?: Record<string, unknown>;
+    /** Output key on blackboard for result */
+    outputKey: string;
+}
+/**
+ * GitHubAction Node
+ *
+ * Executes deterministic GitHub operations (branches, PRs, reviews, issues,
+ * releases) via an activity and stores the result in blackboard.
+ */
+declare class GitHubAction extends ActionNode {
+    private operation;
+    private repo;
+    private params;
+    private outputKey;
+    constructor(config: GitHubActionConfig);
+    protected executeTick(context: TemporalContext): Promise<NodeStatus>;
+}
+
+/**
+ * HumanTask Node
+ *
+ * Pauses workflow execution to present an A2UI surface to a human user
+ * and waits for their response. This node requires the `createHumanTask`
+ * and `waitForHumanTask` activities to be configured in the context.
+ *
+ * Features:
+ * - A2UI component-based UI definition (frozen at design time)
+ * - Data bindings from workflow context (blackboard/input) to A2UI data model
+ * - Variable resolution in title, description, and assignee
+ * - Configurable timeout with onTimeout behavior
+ * - Response data stored in blackboard
+ *
+ * The actual waiting is handled by the Temporal workflow layer using
+ * condition() + signals, not by blocking the activity.
+ */
+
+/**
+ * Configuration for HumanTask node
+ */
+interface HumanTaskConfig extends NodeConfiguration {
+    /** Task title (supports ${bb.x} / ${input.x} resolution) */
+    title: string;
+    /** Task description (supports variable resolution) */
+    description?: string;
+    /** Assignee email (supports variable resolution) */
+    assignee?: string;
+    /** Role-based assignment */
+    assigneeRole?: string;
+    /** A2UI surface definition */
+    a2ui: {
+        /** Component tree definitions */
+        components: A2UIComponent[];
+        /** Maps A2UI JSON Pointer paths to btree expressions */
+        dataBindings?: Record<string, string>;
+    };
+    /** Timeout in milliseconds (default: 24h) */
+    timeoutMs?: number;
+    /** Behavior on timeout: 'expire' | 'approve' | 'reject' */
+    onTimeout?: string;
+    /** Blackboard key prefix for response data (default: node id) */
+    outputKey?: string;
+}
+/**
+ * HumanTask Node
+ *
+ * Creates a human task with an A2UI surface and waits for the user to respond.
+ *
+ * @example YAML
+ * ```yaml
+ * type: HumanTask
+ * id: expense-approval
+ * props:
+ *   title: "Expense Approval"
+ *   description: "Review expense request from ${input.employeeName}"
+ *   assignee: "${input.managerEmail}"
+ *   a2ui:
+ *     components:
+ *       - id: root
+ *         component:
+ *           Column:
+ *             children:
+ *               explicitList: [header, amount-field, actions]
+ *       - id: header
+ *         component:
+ *           Text:
+ *             text: { path: '/title' }
+ *       - id: amount-field
+ *         component:
+ *           TextField:
+ *             text: { path: '/form/amount' }
+ *             label: { literalString: 'Amount ($)' }
+ *       - id: actions
+ *         component:
+ *           Row:
+ *             children:
+ *               explicitList: [approve-btn, reject-btn]
+ *       - id: approve-btn
+ *         component:
+ *           Button:
+ *             child: approve-text
+ *             primary: true
+ *             action:
+ *               name: submit
+ *               context:
+ *                 - key: decision
+ *                   value: { literalString: approved }
+ *       - id: approve-text
+ *         component:
+ *           Text:
+ *             text: { literalString: Approve }
+ *       - id: reject-btn
+ *         component:
+ *           Button:
+ *             child: reject-text
+ *             action:
+ *               name: submit
+ *               context:
+ *                 - key: decision
+ *                   value: { literalString: rejected }
+ *       - id: reject-text
+ *         component:
+ *           Text:
+ *             text: { literalString: Reject }
+ *     dataBindings:
+ *       /title: "Expense Request from ${input.employeeName}"
+ *       /form/amount: "${input.requestedAmount}"
+ *   timeoutMs: 86400000
+ *   onTimeout: expire
+ *   outputKey: approval
+ * ```
+ */
+declare class HumanTask extends ActionNode {
+    private title;
+    private description?;
+    private assignee?;
+    private assigneeRole?;
+    private a2ui;
+    private timeoutMs;
+    private onTimeout;
+    private outputKey?;
+    constructor(config: HumanTaskConfig);
+    protected executeTick(context: TemporalContext): Promise<NodeStatus>;
+}
+
+/**
+ * LLMToolCall Node
+ *
+ * Calls an LLM with tool support and manages the conversation message list.
+ * This is the core node for the decomposed agent loop pattern.
+ *
+ * Unlike LLMChat (single-turn, text-only), LLMToolCall:
+ * - Supports structured content blocks (text, tool_use, tool_result)
+ * - Manages a persistent conversation on the blackboard
+ * - Returns tool calls in the output for ToolExecutor to process
+ * - Always returns SUCCESS (the calling tree decides what to do based on stopReason)
+ */
+
+/**
+ * Configuration for LLMToolCall node
+ */
+interface LLMToolCallConfig extends NodeConfiguration {
+    /** LLM provider: anthropic, openai, google, ollama */
+    provider: LLMProvider;
+    /** Model identifier (supports ${bb.x} resolution) */
+    model: string;
+    /** Optional system prompt (supports variable resolution) */
+    systemPrompt?: string;
+    /** Blackboard key for AgentMessage[] conversation history */
+    messagesKey: string;
+    /** Blackboard key for a new user message to append before calling LLM */
+    userMessageKey?: string;
+    /** Blackboard key for AgentToolDefinition[] (dynamic tools) */
+    toolsKey?: string;
+    /** Static tool definitions (used if toolsKey is not set) */
+    tools?: AgentToolDefinition[];
+    /** Sampling temperature (0-2) */
+    temperature?: number;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Output key on blackboard for response */
+    outputKey: string;
+}
+/**
+ * LLMToolCall Node
+ *
+ * Calls an LLM with tool definitions, manages conversation state,
+ * and writes the response (including any tool calls) to the blackboard.
+ *
+ * @example YAML
+ * ```yaml
+ * type: LLMToolCall
+ * id: call-llm
+ * props:
+ *   provider: anthropic
+ *   model: claude-sonnet-4-20250514
+ *   systemPrompt: "You are a helpful assistant."
+ *   messagesKey: conversationMessages
+ *   userMessageKey: userMessage
+ *   tools:
+ *     - name: get_weather
+ *       description: "Get weather for a city"
+ *       inputSchema:
+ *         type: object
+ *         properties:
+ *           city: { type: string }
+ *         required: [city]
+ *   outputKey: llmResponse
+ * ```
+ */
+declare class LLMToolCall extends ActionNode {
+    private provider;
+    private model;
+    private systemPrompt?;
+    private messagesKey;
+    private userMessageKey?;
+    private toolsKey?;
+    private tools?;
+    private temperature?;
+    private maxTokens?;
+    private outputKey;
+    constructor(config: LLMToolCallConfig);
+    protected executeTick(context: TemporalContext): Promise<NodeStatus>;
+}
+
+/**
+ * ToolExecutor Node
+ *
+ * Executes tool calls from an LLM response and appends results
+ * back to the conversation as tool_result content blocks.
+ *
+ * Works in tandem with LLMToolCall: LLMToolCall produces tool calls,
+ * ToolExecutor runs them and feeds results back to the conversation
+ * so the next LLMToolCall iteration can see them.
+ */
+
+/**
+ * Configuration for ToolExecutor node
+ */
+interface ToolExecutorConfig extends NodeConfiguration {
+    /** Blackboard key for LLMToolCall output (has .toolCalls) */
+    responseKey: string;
+    /** Blackboard key for AgentMessage[] (appends tool_results) */
+    messagesKey: string;
+    /** Optional: where to write tool results array */
+    outputKey?: string;
+}
+/**
+ * ToolExecutor Node
+ *
+ * Executes tool calls from the LLM response and appends tool_result
+ * messages to the conversation for the next LLM turn.
+ *
+ * @example YAML
+ * ```yaml
+ * type: ToolExecutor
+ * id: exec-tools
+ * props:
+ *   responseKey: llmResponse
+ *   messagesKey: conversationMessages
+ * ```
+ */
+declare class ToolExecutor extends ActionNode {
+    private responseKey;
+    private messagesKey;
+    private outputKey?;
+    constructor(config: ToolExecutorConfig);
+    protected executeTick(context: TemporalContext): Promise<NodeStatus>;
+}
+
+/**
+ * WaitForSignal Node
+ *
+ * Pauses workflow execution until an external Temporal signal arrives.
+ * Uses the same pattern as HumanTask: the actual waiting is done via
+ * Temporal's condition() in the workflow layer, exposed as a pseudo-activity.
+ *
+ * Use cases:
+ * - Multi-turn conversational agents waiting for user messages
+ * - External event triggers (webhooks, API callbacks)
+ * - Inter-workflow coordination
+ */
+
+/**
+ * Configuration for WaitForSignal node
+ */
+interface WaitForSignalConfig extends NodeConfiguration {
+    /** Signal name to wait for (e.g., "user_message") */
+    signalName: string;
+    /** Optional discriminator key (supports ${input.x} resolution) */
+    signalKey?: string;
+    /** Timeout in milliseconds (default: 24h) */
+    timeoutMs?: number;
+    /** Blackboard key for received signal data */
+    outputKey: string;
+}
+/**
+ * WaitForSignal Node
+ *
+ * Waits for a generic Temporal signal and stores the payload in the blackboard.
+ *
+ * @example YAML - Wait for user message
+ * ```yaml
+ * type: WaitForSignal
+ * id: wait-msg
+ * props:
+ *   signalName: user_message
+ *   signalKey: "${input.sessionId}"
+ *   timeoutMs: 300000
+ *   outputKey: userInput
+ * ```
+ *
+ * Signal via CLI:
+ * ```bash
+ * temporal workflow signal --workflow-id <id> --name genericSignal \
+ *   --input '{"signalName":"user_message","signalKey":"session-1","data":{"content":"Hello!"}}'
+ * ```
+ */
+declare class WaitForSignal extends ActionNode {
+    private signalName;
+    private signalKey?;
+    private timeoutMs;
+    private outputKey;
+    constructor(config: WaitForSignalConfig);
+    protected executeTick(context: TemporalContext): Promise<NodeStatus>;
+}
+
+/**
+ * ToolRouter Node
+ *
+ * Dynamically selects which tools to expose to the LLM based on
+ * intent matching or explicit rules. Writes the selected tool
+ * definitions to a blackboard key that LLMToolCall reads via toolsKey.
+ *
+ * Use cases:
+ * - Limit tools based on current agent phase (research vs action)
+ * - Select tools based on user intent classification
+ * - Reduce token usage by only sending relevant tools
+ */
+
+/**
+ * Rule for matching intent to tool sets
+ */
+interface ToolRouterRule {
+    /** Regex pattern to match against intent */
+    pattern: string;
+    /** Tool set names to include when pattern matches */
+    toolSets: string[];
+}
+/**
+ * Configuration for ToolRouter node
+ */
+interface ToolRouterConfig extends NodeConfiguration {
+    /** Blackboard key for intent string to match against rules */
+    intentKey: string;
+    /** Named groups of tool definitions */
+    toolSets: Record<string, AgentToolDefinition[]>;
+    /** Tool set names that are always included */
+    defaultTools?: string[];
+    /** Rules: regex patterns mapped to tool set names */
+    rules?: ToolRouterRule[];
+    /** Blackboard key to write selected tools */
+    outputKey: string;
+}
+/**
+ * ToolRouter Node
+ *
+ * Selects tools based on intent matching and writes them to the blackboard.
+ *
+ * @example YAML
+ * ```yaml
+ * type: ToolRouter
+ * id: select-tools
+ * props:
+ *   intentKey: userIntent
+ *   toolSets:
+ *     weather:
+ *       - name: get_weather
+ *         description: "Get weather for a city"
+ *         inputSchema: { type: object, properties: { city: { type: string } } }
+ *     math:
+ *       - name: calculate
+ *         description: "Evaluate a math expression"
+ *         inputSchema: { type: object, properties: { expression: { type: string } } }
+ *     time:
+ *       - name: get_time
+ *         description: "Get current time"
+ *         inputSchema: { type: object, properties: { timezone: { type: string } } }
+ *   defaultTools: [time]
+ *   rules:
+ *     - pattern: "weather|forecast|temperature"
+ *       toolSets: [weather]
+ *     - pattern: "calc|math|compute"
+ *       toolSets: [math]
+ *   outputKey: selectedTools
+ * ```
+ */
+declare class ToolRouter extends ActionNode {
+    private intentKey;
+    private toolSets;
+    private defaultTools;
+    private rules;
+    private outputKey;
+    constructor(config: ToolRouterConfig);
+    protected executeTick(context: TemporalContext): Promise<NodeStatus>;
+}
+
 /**
  * Observability types for workflow execution tracking
  * Used by ExecutionTracker and Analyzer Agent
@@ -3241,7 +3570,7 @@ declare class ExecutionTracker {
  * Usage in workflow:
  * ```typescript
  * import { proxySinks } from '@temporalio/workflow';
- * import type { ObservabilitySinks } from '@wayfarer-ai/btree-workflows';
+ * import type { ObservabilitySinks } from '@q1k-oss/behaviour-tree-workflows';
  *
  * const { events } = proxySinks<ObservabilitySinks>();
  * events.push(nodeEvent);  // Fire-and-forget
@@ -3301,7 +3630,7 @@ type InjectedObservabilitySinks = {
  *
  * Usage in worker:
  * ```typescript
- * import { createObservabilitySinkHandler } from '@wayfarer-ai/btree-workflows';
+ * import { createObservabilitySinkHandler } from '@q1k-oss/behaviour-tree-workflows';
  *
  * const sinks = createObservabilitySinkHandler({
  *   onEvent: (workflowId, runId, event) => {
@@ -3317,4 +3646,4 @@ type InjectedObservabilitySinks = {
  */
 declare function createObservabilitySinkHandler(config?: SinkHandlerConfig): InjectedObservabilitySinks;
 
-export { ActionNode, AlwaysCondition, BaseNode, BehaviorTree, type BtreeActivities, CheckCondition, CodeExecution, type CodeExecutionConfig, type CodeExecutionRequest, type CodeExecutionResult, CompositeNode, ConditionNode, Conditional, ConfigValidationError, ConfigurationError, CounterAction, type DataRef$1 as DataRef, type DataStore, DecoratorNode, Delay, type DeleteFileRequest, type DeleteFileResult, type DownloadFileRequest, type DownloadFileResult, type ExecutionProgress, ExecutionTracker, FailureNode, Fallback, type FileExistsRequest, type FileExistsResult, ForEach, ForceFailure, ForceSuccess, GenerateFile, type GenerateFileConfig, type GenerateFileRequest, type GenerateFileResult, HttpRequest, type HttpRequestActivity, type HttpRequestConfig, type HttpResponseActivity, type IScopedBlackboard, type ITreeRegistry, type InferSchema, type InjectedObservabilitySinks, IntegrationAction, type IntegrationActionConfig, type IntegrationContext, Invert, KeepRunningUntilFailure, type LoadOptions, type LogEventData, LogMessage, type LogMessageConfig, MemoryDataStore, MemorySequence, MockAction, type NodeConfiguration, type NodeConstructor, type NodeEvent, type NodeEventCallback, NodeEventEmitter, NodeEventType, type NodeMetadata, type NodeState, NodeStatus, type ObservabilitySinks, type ObservableNodeEvent, Parallel, type ParallelStrategy, ParseFile, type ParseFileConfig, type ParseFileRequest, type ParseFileResult, type ParsedPath, type PieceActivityRequest as PieceActionRequest, type PieceActivityRequest, type PieceAuth, type PortDefinition, Precondition, PrintAction, type PutOptions, PythonScript, type PythonScriptConfig, type PythonScriptRequest, type PythonScriptResult, ReactiveSequence, Recovery, RegexExtract, type RegexExtractConfig, Registry, Repeat, type ResolveOptions, ResumePoint, type ResumePointConfig, RunOnce, RunningNode, SchemaRegistry, ScopedBlackboard, Selector, SemanticValidationError, Sequence, SequenceWithMemory, type SinkHandlerConfig, SoftAssert, StructureValidationError, type StructuredError, SubTree, SuccessNode, type TemplateLoaderOptions, type TemporalContext, type TickContext, type TimelineEntry, Timeout, type TokenProvider, type TreeDefinition, type TreeNode, type UploadFileRequest, type UploadFileResult, type ValidatedNodeConfiguration, ValidationError, ValidationErrors, type ValidationOptions, type ValidationResult, type VariableContext, WaitAction, While, type WorkflowArgs, type WorkflowResult, YamlSyntaxError, clearPieceCache, createNodeSchema, createObservabilitySinkHandler, envTokenProvider, executePieceAction, extractVariables, getTemplateIds, hasTemplate, hasVariables, isDataRef, isPieceInstalled, listPieceActions, loadTemplate, loadTemplatesFromDirectory, loadTreeFromFile, loadTreeFromYaml, nodeConfigurationSchema, parseYaml, registerStandardNodes, resolveString, resolveValue, safeValidateConfiguration, schemaRegistry, semanticValidator, toYaml, treeDefinitionSchema, validateChildCount, validateChildCountRange, validateCompositeChildren, validateConfiguration, validateDecoratorChildren, validateTreeDefinition, validateYaml, validations, zodErrorToConfigurationError };
+export { A2UIComponent, ActionNode, AgentToolDefinition, AlwaysCondition, BaseNode, BehaviorTree, BrowserAgent, type BrowserAgentConfig, CheckCondition, ClaudeAgent, type ClaudeAgentConfig, ClaudeAgentMcpServerConfig, ClaudeAgentSubagent, CodeExecution, type CodeExecutionConfig, CompositeNode, ConditionNode, Conditional, ConfigValidationError, ConfigurationError, CounterAction, type DataStore, DecoratorNode, Delay, type ExecutionProgress, ExecutionTracker, FailureNode, Fallback, ForEach, ForceFailure, ForceSuccess, GenerateFile, type GenerateFileConfig, GitHubAction, type GitHubActionConfig, GitHubOperation, HttpRequest, type HttpRequestConfig, HumanTask, type HumanTaskConfig, IScopedBlackboard, type InferSchema, type InjectedObservabilitySinks, IntegrationAction, type IntegrationActionConfig, type IntegrationContext, Invert, KeepRunningUntilFailure, LLMChat, type LLMChatConfig, LLMProvider, LLMToolCall, type LLMToolCallConfig, type LoadOptions, LogMessage, type LogMessageConfig, MemoryDataStore, MemorySequence, MessageRole, MockAction, NodeConfiguration, NodeConstructor, NodeEventEmitter, NodeMetadata, type NodeState, NodeStatus, type ObservabilitySinks, type ObservableNodeEvent, Parallel, type ParallelStrategy, ParseFile, type ParseFileConfig, ParseFileRequest, type ParsedPath, PieceActivityRequest as PieceActionRequest, PieceActivityRequest, PortDefinition, Precondition, PrintAction, type PutOptions, PythonScript, type PythonScriptConfig, ReactiveSequence, Recovery, RegexExtract, type RegexExtractConfig, Registry, Repeat, type ResolveOptions, ResumePoint, type ResumePointConfig, RunOnce, RunningNode, SchemaRegistry, ScopedBlackboard, Selector, SemanticValidationError, Sequence, SequenceWithMemory, SetVariable, type SetVariableConfig, type SinkHandlerConfig, SoftAssert, StreamingSink, StructureValidationError, type StructuredError, SubTree, SuccessNode, type TemplateLoaderOptions, TemporalContext, type TimelineEntry, Timeout, TokenProvider, ToolExecutor, type ToolExecutorConfig, ToolRouter, type ToolRouterConfig, type TreeDefinition, TreeNode, type ValidatedNodeConfiguration, ValidationError, ValidationErrors, type ValidationOptions, type ValidationResult, type VariableContext, WaitAction, WaitForSignal, type WaitForSignalConfig, While, WorkflowArgs, WorkflowResult, YamlSyntaxError, clearPieceCache, createNodeSchema, createObservabilitySinkHandler, envTokenProvider, executePieceAction, extractVariables, getTemplateIds, hasTemplate, hasVariables, isDataRef, isPieceInstalled, listPieceActions, loadTemplate, loadTemplatesFromDirectory, loadTreeFromFile, loadTreeFromYaml, nodeConfigurationSchema, parseYaml, registerStandardNodes, resolveString, resolveValue, safeValidateConfiguration, schemaRegistry, semanticValidator, toYaml, treeDefinitionSchema, validateChildCount, validateChildCountRange, validateCompositeChildren, validateConfiguration, validateDecoratorChildren, validateTreeDefinition, validateYaml, validations, zodErrorToConfigurationError };