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

package/dist/index.d.cts

@@ -1,825 +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.cjs';
+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.cjs';
 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 behaviour-tree
- * 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>;
-    /** Execute LLM chat completion */
-    llmChat?: (request: LLMChatRequest) => Promise<LLMChatResult>;
-    /** Execute autonomous browser agent via Browserbase + Stagehand */
-    browserAgent?: (request: BrowserAgentRequest) => Promise<BrowserAgentResult>;
-    /** Execute autonomous Claude agent via Claude Agent SDK */
-    claudeAgent?: (request: ClaudeAgentRequest) => Promise<ClaudeAgentResult>;
-    /** Execute GitHub operations (create branch, PR, merge, etc.) */
-    githubAction?: (request: GitHubActionRequest) => Promise<GitHubActionResult>;
-    /** Create a human task (inserts into tasks table, returns taskId) */
-    createHumanTask?: (request: CreateHumanTaskRequest) => Promise<CreateHumanTaskResult>;
-    /** Wait for a human task to be completed (implemented as Temporal condition in workflow) */
-    waitForHumanTask?: (request: WaitForHumanTaskRequest) => Promise<WaitForHumanTaskResult>;
-}
-/**
- * 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;
-}
-/**
- * Supported LLM providers
- */
-type LLMProvider = "anthropic" | "openai" | "google" | "ollama";
-/**
- * Message role in conversation
- */
-type MessageRole = "system" | "user" | "assistant";
-/**
- * Single message in a conversation
- */
-interface LLMMessage {
-    role: MessageRole;
-    content: string;
-}
-/**
- * Request for LLM chat completion
- */
-interface LLMChatRequest {
-    /** LLM provider to use */
-    provider: LLMProvider;
-    /** Model identifier (e.g., "claude-sonnet-4-20250514", "gpt-4", "gemini-pro") */
-    model: string;
-    /** Conversation messages */
-    messages: LLMMessage[];
-    /** Optional system prompt (prepended as system message) */
-    systemPrompt?: string;
-    /** Sampling temperature (0-2, default: 1) */
-    temperature?: number;
-    /** Maximum tokens to generate */
-    maxTokens?: number;
-    /** Response format: "text" or "json" */
-    responseFormat?: "text" | "json";
-    /** JSON schema for structured output (when responseFormat is "json") */
-    jsonSchema?: Record<string, unknown>;
-    /** Request timeout in milliseconds */
-    timeout?: number;
-    /** Ollama-specific: base URL for local instance */
-    baseUrl?: string;
-}
-/**
- * Result from LLM chat completion
- */
-interface LLMChatResult {
-    /** Generated response content */
-    content: string;
-    /** Parsed JSON if responseFormat was "json" */
-    parsed?: unknown;
-    /** Token usage statistics */
-    usage: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
-    /** Model used for completion */
-    model: string;
-    /** Finish reason */
-    finishReason: "stop" | "length" | "content_filter" | "tool_calls" | "error";
-}
-/**
- * Request for autonomous browser agent execution
- */
-interface BrowserAgentRequest {
-    /** Goal/instruction for the agent to achieve */
-    goal: string;
-    /** Starting URL (optional - agent may navigate) */
-    startUrl?: string;
-    /** Context ID for persisting cookies/auth/cache (server-side) */
-    contextId?: string;
-    /** Whether to persist context changes (default: false) */
-    persistContext?: boolean;
-    /** Timeout for entire agent execution (ms) */
-    timeout?: number;
-    /** Max steps/actions the agent can take */
-    maxSteps?: number;
-    /** LLM provider for agent reasoning */
-    llmProvider?: LLMProvider;
-    /** LLM model for agent reasoning */
-    llmModel?: string;
-}
-/**
- * Result from browser agent execution
- */
-interface BrowserAgentResult {
-    /** Whether the agent achieved the goal (from Stagehand) */
-    success: boolean;
-    /** Whether execution completed (false if hit maxSteps limit) */
-    completed: boolean;
-    /** Human-readable summary of what was accomplished */
-    message: string;
-    actions: Array<{
-        type: string;
-        reasoning?: string;
-        taskCompleted: boolean;
-        pageUrl: string;
-        timestamp: number;
-    }>;
-    usage: {
-        inputTokens: number;
-        outputTokens: number;
-        reasoningTokens: number;
-    };
-    /** Browserbase session ID */
-    sessionId: string;
-    /** URL to view session recording */
-    debugUrl: string;
-    /** Final URL after agent execution */
-    finalUrl: string;
-    /** Context ID (for use in subsequent calls) */
-    contextId?: string;
-    executionTimeMs: number;
-}
-/**
- * MCP server configuration for ClaudeAgent
- */
-type ClaudeAgentMcpServerConfig = {
-    type?: "stdio";
-    command: string;
-    args?: string[];
-    env?: Record<string, string>;
-} | {
-    type: "sse";
-    url: string;
-    headers?: Record<string, string>;
-} | {
-    type: "http";
-    url: string;
-    headers?: Record<string, string>;
-};
-/**
- * Subagent definition for ClaudeAgent
- */
-interface ClaudeAgentSubagent {
-    description: string;
-    prompt: string;
-    tools?: string[];
-    model?: "sonnet" | "opus" | "haiku" | "inherit";
-}
-/**
- * Request for autonomous Claude agent execution
- */
-interface ClaudeAgentRequest {
-    /** Task prompt for the agent */
-    prompt: string;
-    /** Model to use (e.g., "claude-sonnet-4-5-20250929") */
-    model?: string;
-    /** System prompt for agent behavior */
-    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 */
-    cwd?: string;
-    /** MCP server configurations */
-    mcpServers?: Record<string, ClaudeAgentMcpServerConfig>;
-    /** Subagent definitions */
-    agents?: Record<string, ClaudeAgentSubagent>;
-    /** Extra context data passed from blackboard */
-    context?: Record<string, unknown>;
-}
-/**
- * Result from Claude agent execution
- */
-interface ClaudeAgentResult {
-    /** Final text result from the agent */
-    result: string;
-    /** Session ID for resuming/continuing */
-    sessionId: string;
-    /** Whether the agent completed successfully */
-    success: boolean;
-    /** Number of conversation turns used */
-    numTurns: number;
-    /** Total cost in USD */
-    totalCostUsd: number;
-    /** Token usage statistics */
-    usage: {
-        inputTokens: number;
-        outputTokens: number;
-        cacheReadTokens: number;
-        cacheCreationTokens: number;
-    };
-    /** Execution duration in milliseconds */
-    durationMs: number;
-    /** Errors encountered during execution */
-    errors?: string[];
-}
-/**
- * Supported GitHub operations
- */
-type GitHubOperation = "createBranch" | "createPullRequest" | "getPullRequest" | "mergePullRequest" | "closePullRequest" | "createReview" | "listIssues" | "addLabels" | "createComment" | "createRelease";
-/**
- * Request for a GitHub operation
- */
-interface GitHubActionRequest {
-    /** The operation to perform */
-    operation: GitHubOperation;
-    /** Repository in "owner/repo" format */
-    repo: string;
-    /** Operation-specific parameters */
-    params: Record<string, unknown>;
-}
-/**
- * Result of a GitHub operation
- */
-interface GitHubActionResult {
-    /** Whether the operation succeeded */
-    success: boolean;
-    /** Operation-specific response data */
-    data: unknown;
-    /** The operation that was performed */
-    operation: GitHubOperation;
-}
-/**
- * A2UI component definition for human task surfaces
- */
-interface A2UIComponent {
-    id: string;
-    component: Record<string, unknown>;
-    weight?: number;
-}
-/**
- * Request to create a human task
- */
-interface CreateHumanTaskRequest {
-    /** Btree node ID that created this task */
-    nodeId: string;
-    /** Tenant ID for multi-tenancy */
-    tenantId: string;
-    /** Execution/workflow ID */
-    executionId: string;
-    /** Task title */
-    title: string;
-    /** Task description */
-    description?: string;
-    /** Direct assignee email */
-    assigneeEmail?: string;
-    /** Role-based assignment */
-    assigneeRole?: string;
-    /** A2UI component definitions (the frozen surface template) */
-    a2uiComponents: A2UIComponent[];
-    /** Resolved A2UI data model (bindings already evaluated) */
-    a2uiDataModel: Record<string, unknown>;
-    /** Timeout in milliseconds before task expires */
-    timeoutMs?: number;
-    /** What to do on timeout: 'expire' | 'approve' | 'reject' */
-    onTimeout?: string;
-    /** Optional metadata */
-    metadata?: Record<string, unknown>;
-}
-/**
- * Result from creating a human task
- */
-interface CreateHumanTaskResult {
-    /** Generated task ID (UUID) */
-    taskId: string;
-    /** URL where the task can be accessed */
-    taskUrl: string;
-}
-/**
- * Request to wait for a human task to be completed
- */
-interface WaitForHumanTaskRequest {
-    /** Task ID to wait for */
-    taskId: string;
-    /** Node ID (for signal routing) */
-    nodeId: string;
-    /** Timeout in milliseconds */
-    timeoutMs?: number;
-    /** What to do on timeout */
-    onTimeout?: string;
-}
-/**
- * Result from a completed human task
- */
-interface WaitForHumanTaskResult {
-    /** Whether the task was completed (vs timed out) */
-    completed: boolean;
-    /** Submitted form data from the user */
-    submittedData?: Record<string, unknown>;
-    /** Decision string (e.g., 'approved', 'rejected') */
-    decision?: string;
-    /** User ID who completed the task */
-    completedBy?: string;
-    /** Timestamp when completed */
-    completedAt?: string;
-    /** Whether the task timed out */
-    timedOut?: boolean;
-}
-/**
- * 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
  */
@@ -1558,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
@@ -1792,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;
@@ -1803,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>;
 }
 /**
@@ -2043,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
  *
@@ -3818,6 +3105,268 @@ declare class HumanTask extends ActionNode {
     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
@@ -4097,4 +3646,4 @@ type InjectedObservabilitySinks = {
  */
 declare function createObservabilitySinkHandler(config?: SinkHandlerConfig): InjectedObservabilitySinks;
 
-export { type A2UIComponent, ActionNode, AlwaysCondition, BaseNode, BehaviorTree, BrowserAgent, type BrowserAgentConfig, type BrowserAgentRequest, type BrowserAgentResult, type BtreeActivities, CheckCondition, ClaudeAgent, type ClaudeAgentConfig, type ClaudeAgentMcpServerConfig, type ClaudeAgentRequest, type ClaudeAgentResult, type ClaudeAgentSubagent, CodeExecution, type CodeExecutionConfig, type CodeExecutionRequest, type CodeExecutionResult, CompositeNode, ConditionNode, Conditional, ConfigValidationError, ConfigurationError, CounterAction, type CreateHumanTaskRequest, type CreateHumanTaskResult, 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, GitHubAction, type GitHubActionConfig, type GitHubActionRequest, type GitHubActionResult, type GitHubOperation, HttpRequest, type HttpRequestActivity, type HttpRequestConfig, type HttpResponseActivity, HumanTask, type HumanTaskConfig, type IScopedBlackboard, type ITreeRegistry, type InferSchema, type InjectedObservabilitySinks, IntegrationAction, type IntegrationActionConfig, type IntegrationContext, Invert, KeepRunningUntilFailure, LLMChat, type LLMChatConfig, type LLMChatRequest, type LLMChatResult, type LLMMessage, type LLMProvider, type LoadOptions, type LogEventData, LogMessage, type LogMessageConfig, MemoryDataStore, MemorySequence, type MessageRole, 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, type WaitForHumanTaskRequest, type WaitForHumanTaskResult, 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 };