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

package/dist/types-BJPlUisg.d.ts

@@ -0,0 +1,931 @@
+/**
+ * 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>;
+    /** Execute a single LLM turn with tool calling support */
+    agentLoopTurn?: (request: AgentLoopTurnRequest) => Promise<AgentLoopTurnResult>;
+    /** Execute a tool call by name */
+    executeAgentTool?: (request: ExecuteAgentToolRequest) => Promise<ExecuteAgentToolResult>;
+    /** Wait for a generic Temporal signal (implemented as condition in workflow) */
+    waitForSignal?: (request: WaitForSignalRequest) => Promise<WaitForSignalResult>;
+}
+/**
+ * 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;
+    /** Uploaded filename */
+    filename: string;
+    /** File size in bytes */
+    sizeBytes: number;
+}
+interface DownloadFileRequest {
+    /** Reference to file in storage */
+    dataRef: DataRef;
+}
+interface DownloadFileResult {
+    /** Base64-encoded file content */
+    fileBytes: string;
+    /** File size in bytes */
+    sizeBytes: number;
+}
+interface DeleteFileRequest {
+    /** Reference to file in storage */
+    dataRef: DataRef;
+}
+interface DeleteFileResult {
+    /** Whether deletion was successful */
+    deleted: boolean;
+    /** Key of deleted file */
+    key: string;
+}
+interface FileExistsRequest {
+    /** Reference to file in storage */
+    dataRef: DataRef;
+}
+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 {
+    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>;
+    /** 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>;
+    /** 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;
+}
+/**
+ * Content block types for structured LLM messages (Anthropic-compatible)
+ */
+type AgentContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+    is_error?: boolean;
+};
+/**
+ * Rich message format supporting both plain text and structured content blocks
+ */
+interface AgentMessage {
+    role: "user" | "assistant" | "system";
+    content: string | AgentContentBlock[];
+}
+/**
+ * Tool definition passed to the LLM for tool calling
+ */
+interface AgentToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+/**
+ * A single tool call from an LLM response
+ */
+interface AgentToolCall {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+/**
+ * Request for a single LLM turn with tool support
+ */
+interface AgentLoopTurnRequest {
+    provider: LLMProvider;
+    model: string;
+    systemPrompt?: string;
+    messages: AgentMessage[];
+    tools?: AgentToolDefinition[];
+    temperature?: number;
+    maxTokens?: number;
+    streamChannelId?: string;
+}
+/**
+ * Result from a single LLM turn with tool support
+ */
+interface AgentLoopTurnResult {
+    content: string;
+    toolCalls?: AgentToolCall[];
+    stopReason: "end_turn" | "tool_use" | "max_tokens";
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+/**
+ * Request to execute a tool by name
+ */
+interface ExecuteAgentToolRequest {
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    context?: Record<string, unknown>;
+}
+/**
+ * Result from executing a tool
+ */
+interface ExecuteAgentToolResult {
+    content: string;
+    isError: boolean;
+}
+/**
+ * Payload for generic Temporal signals
+ */
+interface GenericSignalPayload {
+    signalName: string;
+    signalKey?: string;
+    data: Record<string, unknown>;
+}
+/**
+ * Request to wait for a Temporal signal
+ */
+interface WaitForSignalRequest {
+    signalName: string;
+    signalKey?: string;
+    timeoutMs?: number;
+}
+/**
+ * Result from waiting for a signal
+ */
+interface WaitForSignalResult {
+    received: boolean;
+    data?: Record<string, unknown>;
+    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>;
+}
+
+export { type ClaudeAgentResult as $, type A2UIComponent as A, type BtreeActivities as B, type ClaudeAgentMcpServerConfig as C, type DataRef as D, type UploadFileResult as E, type DownloadFileRequest as F, type GitHubOperation as G, type HttpRequestActivity as H, type IScopedBlackboard as I, type DownloadFileResult as J, type DeleteFileRequest as K, type LLMProvider as L, type MessageRole as M, NodeStatus as N, type DeleteFileResult as O, type PortDefinition as P, type FileExistsRequest as Q, type FileExistsResult as R, type LLMMessage as S, type TreeNode as T, type UploadFileRequest as U, type LLMChatRequest as V, type WorkflowArgs as W, type LLMChatResult as X, type BrowserAgentRequest as Y, type BrowserAgentResult as Z, type ClaudeAgentRequest as _, type NodeConfiguration as a, type GitHubActionRequest as a0, type GitHubActionResult as a1, type CreateHumanTaskRequest as a2, type CreateHumanTaskResult as a3, type WaitForHumanTaskRequest as a4, type WaitForHumanTaskResult as a5, type AgentContentBlock as a6, type AgentMessage as a7, type AgentToolCall as a8, type AgentLoopTurnRequest as a9, type AgentLoopTurnResult as aa, type ExecuteAgentToolRequest as ab, type ExecuteAgentToolResult as ac, type GenericSignalPayload as ad, type WaitForSignalRequest as ae, type WaitForSignalResult as af, NodeEventEmitter as b, type TemporalContext as c, type WorkflowResult as d, type NodeConstructor as e, type NodeMetadata as f, type TokenProvider as g, type PieceActivityRequest as h, type ParseFileRequest as i, type ClaudeAgentSubagent as j, type AgentToolDefinition as k, type ITreeRegistry as l, type PieceAuth as m, type PythonScriptRequest as n, type PythonScriptResult as o, type ParseFileResult as p, type GenerateFileRequest as q, type GenerateFileResult as r, type HttpResponseActivity as s, type CodeExecutionRequest as t, type CodeExecutionResult as u, NodeEventType as v, type LogEventData as w, type NodeEvent as x, type NodeEventCallback as y, type TickContext as z };