@elevasis/ui 1.0.0

package/dist/execution/index.d.ts

@@ -0,0 +1,1090 @@
+import { Node, Edge, NodeProps, EdgeProps } from '@xyflow/react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { BadgeProps } from '@mantine/core';
+import * as react from 'react';
+
+/**
+ * Workflow-specific logging types and utilities
+ */
+
+interface WorkflowExecutionContext {
+    type: 'workflow';
+    contextType: 'workflow-execution';
+    executionId: string;
+    workflowId: string;
+    workflowName?: string;
+    organizationId: string;
+    executionPath?: string[];
+}
+interface WorkflowFailureContext {
+    type: 'workflow';
+    contextType: 'workflow-failure';
+    executionId: string;
+    workflowId: string;
+    error: string;
+}
+interface StepStartedContext {
+    type: 'workflow';
+    contextType: 'step-started';
+    stepId: string;
+    stepStatus: 'started';
+    input: unknown;
+    startTime: number;
+}
+interface StepCompletedContext {
+    type: 'workflow';
+    contextType: 'step-completed';
+    stepId: string;
+    stepStatus: 'completed';
+    output: unknown;
+    duration: number;
+    isTerminal: boolean;
+    startTime: number;
+    endTime: number;
+}
+interface StepFailedContext {
+    type: 'workflow';
+    contextType: 'step-failed';
+    stepId: string;
+    stepStatus: 'failed';
+    error: string;
+    duration: number;
+    startTime: number;
+    endTime: number;
+}
+interface ConditionalRouteContext {
+    type: 'workflow';
+    contextType: 'conditional-route';
+    stepId: string;
+    target: string;
+    error?: string;
+}
+interface ExecutionPathContext {
+    type: 'workflow';
+    contextType: 'execution-path';
+    executionPath: string[];
+}
+type WorkflowLogContext = WorkflowExecutionContext | WorkflowFailureContext | StepStartedContext | StepCompletedContext | StepFailedContext | ConditionalRouteContext | ExecutionPathContext;
+interface WorkflowLogMessage {
+    level: ExecutionLogLevel;
+    message: string;
+    timestamp: number;
+    context?: WorkflowLogContext;
+}
+
+/**
+ * Agent-specific logging types
+ * Simplified 2-event model: lifecycle, iteration
+ *
+ * Design Philosophy:
+ * - LIFECYCLE EVENTS: Structural checkpoints (initialization, iteration, completion)
+ * - ITERATION EVENTS: Execution activities (reasoning, actions during iterations)
+ */
+
+/**
+ * Agent lifecycle stages
+ * Universal checkpoints that apply to all agent executions
+ */
+type AgentLifecycle = 'initialization' | 'iteration' | 'completion';
+/**
+ * Iteration event types
+ * Activities that occur during agent iterations
+ */
+type IterationEventType = 'reasoning' | 'action' | 'tool-call';
+/**
+ * Base fields shared by all lifecycle events
+ */
+interface AgentLifecycleEventBase {
+    type: 'agent';
+    agentId: string;
+    lifecycle: AgentLifecycle;
+    sessionId?: string;
+}
+/**
+ * Lifecycle started event - emitted when a phase begins
+ * REQUIRED: startTime (phase has started, no end yet)
+ */
+interface AgentLifecycleStartedEvent extends AgentLifecycleEventBase {
+    stage: 'started';
+    startTime: number;
+    iteration?: number;
+}
+/**
+ * Lifecycle completed event - emitted when a phase succeeds
+ * REQUIRED: startTime, endTime, duration (phase has finished successfully)
+ */
+interface AgentLifecycleCompletedEvent extends AgentLifecycleEventBase {
+    stage: 'completed';
+    startTime: number;
+    endTime: number;
+    duration: number;
+    iteration?: number;
+    attempts?: number;
+    memorySize?: {
+        sessionMemoryKeys: number;
+        historyEntries: number;
+    };
+}
+/**
+ * Lifecycle failed event - emitted when a phase fails
+ * REQUIRED: startTime, endTime, duration, error (phase has finished with error)
+ */
+interface AgentLifecycleFailedEvent extends AgentLifecycleEventBase {
+    stage: 'failed';
+    startTime: number;
+    endTime: number;
+    duration: number;
+    error: string;
+    iteration?: number;
+}
+/**
+ * Union type for all lifecycle events
+ * Discriminated by 'stage' field for type narrowing
+ */
+type AgentLifecycleEvent = AgentLifecycleStartedEvent | AgentLifecycleCompletedEvent | AgentLifecycleFailedEvent;
+/**
+ * Placeholder data for MVP
+ * Will be typed per actionType in future
+ */
+interface ActionPlaceholderData {
+    message: string;
+}
+/**
+ * Iteration event - captures activities during agent iterations
+ * Consolidates reasoning (LLM thought process) and actions (tool use, memory ops, etc.)
+ */
+interface AgentIterationEvent {
+    type: 'agent';
+    agentId: string;
+    lifecycle: 'iteration';
+    eventType: IterationEventType;
+    iteration: number;
+    sessionId?: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    output?: string;
+    actionType?: string;
+    data?: ActionPlaceholderData;
+}
+/**
+ * Tool call event - captures individual tool executions during iterations
+ * Provides granular timing for each tool invocation
+ */
+interface AgentToolCallEvent {
+    type: 'agent';
+    agentId: string;
+    lifecycle: 'iteration';
+    eventType: 'tool-call';
+    iteration: number;
+    sessionId?: string;
+    toolName: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    success: boolean;
+    error?: string;
+    input?: Record<string, unknown>;
+    output?: unknown;
+}
+/**
+ * Union type for all agent log contexts
+ * 3 event types total (lifecycle, iteration, tool-call)
+ */
+type AgentLogContext = AgentLifecycleEvent | AgentIterationEvent | AgentToolCallEvent;
+
+/**
+ * Base execution logger for Execution Engine
+ */
+type ExecutionLogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+type LogContext = WorkflowLogContext | AgentLogContext;
+interface ExecutionLogMessage {
+    level: ExecutionLogLevel;
+    message: string;
+    timestamp: number;
+    context?: LogContext;
+}
+
+/**
+ * Shared form field types for dynamic form generation
+ * Used by: Command Queue, Execution Runner UI, future form-based features
+ */
+/**
+ * Supported form field types for action payloads
+ * Maps to Mantine form components
+ */
+type FormFieldType = 'text' | 'textarea' | 'number' | 'select' | 'checkbox' | 'radio' | 'richtext';
+
+/**
+ * Serialized Registry Types
+ *
+ * Pre-computed JSON-safe types for API responses and Command View.
+ * Serialization happens once at API startup, enabling instant response times.
+ */
+
+/**
+ * Serialized form field for API responses
+ */
+interface SerializedFormField {
+    name: string;
+    label: string;
+    type: FormFieldType;
+    defaultValue?: unknown;
+    required?: boolean;
+    placeholder?: string;
+    description?: string;
+    options?: Array<{
+        label: string;
+        value: string | number;
+    }>;
+    min?: number;
+    max?: number;
+}
+/**
+ * Serialized form schema for API responses
+ */
+interface SerializedFormSchema {
+    title?: string;
+    description?: string;
+    fields: SerializedFormField[];
+    layout?: 'vertical' | 'horizontal' | 'grid';
+}
+/**
+ * Serialized execution form schema for API responses
+ */
+interface SerializedExecutionFormSchema extends SerializedFormSchema {
+    fieldMappings?: Record<string, string>;
+    submitButton?: {
+        label?: string;
+        loadingLabel?: string;
+        confirmMessage?: string;
+    };
+}
+/**
+ * Serialized schedule config for API responses
+ */
+interface SerializedScheduleConfig {
+    enabled: boolean;
+    defaultSchedule?: string;
+    allowedPatterns?: string[];
+}
+/**
+ * Serialized webhook config for API responses
+ */
+interface SerializedWebhookConfig {
+    enabled: boolean;
+    payloadSchema?: unknown;
+}
+/**
+ * Serialized execution interface for API responses
+ */
+interface SerializedExecutionInterface {
+    form: SerializedExecutionFormSchema;
+    schedule?: SerializedScheduleConfig;
+    webhook?: SerializedWebhookConfig;
+}
+/**
+ * Serialized agent definition (JSON-safe)
+ * Result of serializeDefinition(AgentDefinition)
+ */
+interface SerializedAgentDefinition {
+    config: {
+        resourceId: string;
+        name: string;
+        description: string;
+        version: string;
+        type: 'agent';
+        status: 'dev' | 'prod';
+        /** Whether this resource is archived and should be excluded from registration and deployment */
+        archived?: boolean;
+        systemPrompt: string;
+        constraints?: {
+            maxIterations?: number;
+            timeout?: number;
+            maxSessionMemoryKeys?: number;
+            maxMemoryTokens?: number;
+        };
+        sessionCapable?: boolean;
+        memoryPreferences?: string;
+    };
+    modelConfig: {
+        provider: string;
+        model: string;
+        apiKey: string;
+        temperature: number;
+        maxOutputTokens: number;
+        topP?: number;
+        modelOptions?: Record<string, unknown>;
+    };
+    contract: {
+        inputSchema: object;
+        outputSchema?: object;
+    };
+    tools: Array<{
+        name: string;
+        description: string;
+        inputSchema?: object;
+        outputSchema?: object;
+    }>;
+    knowledgeMap?: {
+        nodeCount: number;
+        nodes: Array<{
+            id: string;
+            description: string;
+            loaded: boolean;
+            hasPrompt: boolean;
+        }>;
+    };
+    metricsConfig?: object;
+    interface?: SerializedExecutionInterface;
+}
+/**
+ * Serialized workflow definition (JSON-safe)
+ * Result of serializeDefinition(WorkflowDefinition)
+ */
+interface SerializedWorkflowDefinition {
+    config: {
+        resourceId: string;
+        name: string;
+        description: string;
+        version: string;
+        type: 'workflow';
+        status: 'dev' | 'prod';
+        /** Whether this resource is archived and should be excluded from registration and deployment */
+        archived?: boolean;
+    };
+    entryPoint: string;
+    steps: Array<{
+        id: string;
+        name: string;
+        description: string;
+        inputSchema?: object;
+        outputSchema?: object;
+        next: {
+            type: 'linear' | 'conditional';
+            target?: string;
+            routes?: Array<{
+                target: string;
+            }>;
+            default?: string;
+        } | null;
+    }>;
+    contract: {
+        inputSchema: object;
+        outputSchema?: object;
+    };
+    metricsConfig?: object;
+    interface?: SerializedExecutionInterface;
+}
+
+/**
+ * Workflow step state
+ * Aggregates step context events with timing and logs
+ */
+interface StepState {
+    stepId: string;
+    stepName: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    startTime?: number;
+    endTime?: number;
+    duration?: number;
+    input?: unknown;
+    output?: unknown;
+    error?: unknown;
+    logs: WorkflowLogMessage[];
+}
+/**
+ * Complete workflow execution data for node visualization
+ * Parsed from execution logs
+ */
+interface WorkflowNodeVisualizerData {
+    steps: StepState[];
+    totalDuration: number;
+    isRunning: boolean;
+}
+/**
+ * Step data extracted from execution logs
+ * Used to provide detailed step information in unified graph nodes
+ */
+interface StepExecutionData {
+    /** Final execution status for this step */
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    /** Step execution duration in milliseconds */
+    duration?: number;
+    /** Step input data */
+    input?: unknown;
+    /** Step output data */
+    output?: unknown;
+    /** Error data if step failed */
+    error?: unknown;
+    /** Log messages from this step (reserved for future use) */
+    logs?: unknown[];
+}
+/**
+ * Execution path tracking state
+ *
+ * Tracks which steps have been executed and which edges were taken during workflow
+ * execution. This state is built from SSE execution log events and used to compute
+ * the visual dimming/highlighting of nodes and edges.
+ *
+ * Algorithm:
+ * - `executedSteps` provides O(1) lookup for "has this step been reached?"
+ * - `executedStepsOrdered` preserves execution order for edge inference
+ * - `takenEdges` comes from `conditional-route` SSE events + linear step inference
+ * - `currentStepId` tracks the actively running step for animation
+ * - `stepStatusMap` provides final status for each executed step
+ * - `stepDataMap` provides detailed execution data (duration, input, output, error)
+ */
+interface ExecutionPathState {
+    /** Set of step IDs that have been executed (O(1) lookup) */
+    executedSteps: Set<string>;
+    /** Step IDs in execution order (for inferring linear edges) */
+    executedStepsOrdered: string[];
+    /** Set of edge IDs that were traversed (format: "edge-{source}-{target}") */
+    takenEdges: Set<string>;
+    /** Currently running step ID (undefined if no step is running) */
+    currentStepId?: string;
+    /** Map of step IDs to their final execution status */
+    stepStatusMap?: Map<string, 'pending' | 'running' | 'completed' | 'failed'>;
+    /** Map of step IDs to their execution data (duration, input, output, error) */
+    stepDataMap?: Map<string, StepExecutionData>;
+}
+
+/**
+ * Agent timeline and observability types
+ * Used for UI timeline visualization and backend processing
+ */
+
+/**
+ * Sub-activity within an iteration
+ * Represents reasoning, actions, or tool calls with timing
+ */
+interface SubActivity {
+    type: 'reasoning' | 'action' | 'tool-call';
+    startTime: number;
+    endTime: number;
+    duration: number;
+    details: AgentIterationEvent | AgentToolCallEvent;
+}
+/**
+ * Agent iteration state
+ * Aggregates lifecycle events and sub-activities for a single iteration
+ */
+interface AgentIteration {
+    iterationNumber: number;
+    status: 'running' | 'completed' | 'failed' | 'pending';
+    iterationEvents: AgentIterationEvent[];
+    duration?: number;
+    timestamp: number;
+    subActivities: SubActivity[];
+    startTime?: number;
+    endTime?: number;
+}
+/**
+ * Agent lifecycle node state
+ * Represents initialization or completion phase
+ */
+interface AgentLifecycleNode {
+    type: 'initialization' | 'completion';
+    status: 'running' | 'completed' | 'failed' | 'pending';
+    duration?: number;
+    timestamp?: number;
+    startTime?: number;
+    endTime?: number;
+}
+/**
+ * Complete agent execution data for timeline visualization
+ * Parsed from execution logs
+ */
+interface AgentIterationData {
+    initialization: AgentLifecycleNode;
+    iterations: AgentIteration[];
+    completion: AgentLifecycleNode;
+    currentIteration: number | null;
+    totalIterations: number;
+    totalDuration?: number;
+    status: 'running' | 'completed' | 'failed' | 'warning';
+}
+
+/**
+ * Resource Registry type definitions
+ */
+
+/**
+ * Environment/deployment status for resources
+ */
+type ResourceStatus = 'dev' | 'prod';
+
+type ExecutionStatus = 'pending' | 'running' | 'completed' | 'failed' | 'warning';
+interface APIExecutionSummary {
+    id: string;
+    status: ExecutionStatus;
+    startTime: number;
+    endTime?: number;
+    resourceStatus?: ResourceStatus;
+}
+interface APIExecutionDetail extends APIExecutionSummary {
+    executionLogs: ExecutionLogMessage[];
+    input?: unknown;
+    result?: unknown;
+    error?: string;
+    resourceStatus: ResourceStatus;
+    apiVersion?: string | null;
+    resourceVersion?: string | null;
+    sdkVersion?: string | null;
+}
+
+/**
+ * Merges SSE-streamed logs with fetched execution data for instant log display.
+ * Deduplicates by composite key (timestamp + message) to avoid showing the same
+ * log twice while preserving distinct logs that share the same millisecond.
+ *
+ * When no streaming logs exist or all SSE logs are already in the fetched data,
+ * returns the fetched execution unchanged for referential stability.
+ */
+declare function useMergedExecution(fetchedExecution: APIExecutionDetail | undefined, streamingLogs: ExecutionLogMessage[] | undefined): APIExecutionDetail | undefined;
+
+/**
+ * Hook to track execution path from execution logs
+ *
+ * This hook parses execution logs to determine:
+ * 1. Which steps have been executed
+ * 2. Which edges were taken during execution
+ * 3. The current running step
+ *
+ * Algorithm:
+ * - Track executed steps from step-started events
+ * - Track taken edges from conditional-route events (explicit routing decisions)
+ * - Infer linear edges from step execution order (consecutive steps in linear flow)
+ * - Track current step from step-started/completed/failed events
+ *
+ * Edge ID Format (must match useWorkflowStepsLayout):
+ * - Linear: edge-{source}-{target}
+ * - Conditional: edge-{source}-{target}
+ * - Default: edge-{source}-{target}-default
+ *
+ * @param executionLogs - Array of execution log messages from SSE
+ * @param workflowDefinition - Workflow definition
+ * @returns Execution path state or undefined if no logs available
+ *
+ * @see unified-workflow-graph-design-plan.mdx for algorithm details
+ */
+declare function useExecutionPath(executionLogs: ExecutionLogMessage[] | undefined, workflowDefinition: SerializedWorkflowDefinition | undefined): ExecutionPathState | undefined;
+
+/**
+ * Parse execution logs to extract step states for timeline visualization
+ */
+declare function useTimelineData(execution: APIExecutionDetail | undefined, resourceDefinition: SerializedWorkflowDefinition): WorkflowNodeVisualizerData | undefined;
+
+declare function useAgentIterationData(execution: APIExecutionDetail | undefined, resourceDefinition: SerializedAgentDefinition): AgentIterationData | null;
+
+/**
+ * Timeline Bar Props
+ * Represents a single horizontal bar in the timeline
+ */
+interface TimelineBarProps {
+    startTime: number;
+    endTime: number;
+    executionStart: number;
+    executionEnd: number;
+    status: ExecutionStatus;
+    label?: string;
+    onClick?: () => void;
+    nodeId?: string | number;
+    isSelected?: boolean;
+    hasSelection?: boolean;
+}
+/**
+ * Timeline Row Props
+ * Represents a row with label + one or more bars
+ */
+interface TimelineRowProps {
+    label: string;
+    bars: Array<{
+        startTime: number;
+        endTime: number;
+        status: ExecutionStatus;
+        label?: string;
+        onClick?: () => void;
+        nodeId?: string | number;
+    }>;
+    executionStart: number;
+    executionEnd: number;
+    indent?: number;
+    selectedNodeId?: string | number | null;
+}
+/**
+ * Timeline Container Props
+ * Outer container for the timeline
+ */
+interface TimelineContainerProps {
+    executionStart: number;
+    executionEnd: number;
+    children: React.ReactNode;
+}
+/**
+ * Graph visualization mode
+ *
+ * - 'definition': Static view for workflow definition display (no dimming, all nodes visible)
+ * - 'execution': Dynamic view with execution state overlay (dimming based on execution path)
+ */
+type GraphMode = 'definition' | 'execution';
+/**
+ * Unified node data combining workflow structure and execution state
+ */
+interface UnifiedWorkflowNodeData {
+    id: string;
+    name: string;
+    description: string;
+    isEntryPoint: boolean;
+    isEndNode: boolean;
+    isConditional: boolean;
+    routeCount?: number;
+    executionStatus?: 'pending' | 'running' | 'completed' | 'failed';
+    duration?: number;
+    input?: unknown;
+    output?: unknown;
+    error?: unknown;
+    logs?: WorkflowLogMessage[];
+    isExecuted: boolean;
+    isDimmed: boolean;
+    isSelected?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Unified edge data combining workflow structure and execution state
+ */
+interface UnifiedWorkflowEdgeData {
+    edgeType: 'linear' | 'conditional' | 'default';
+    label?: string;
+    wasTaken: boolean;
+    sourceStatus?: ExecutionStatus;
+    targetStatus?: ExecutionStatus;
+    isDimmed: boolean;
+    isAnimated: boolean;
+    [key: string]: unknown;
+}
+type WorkflowEdgeType = 'linear' | 'conditional' | 'default';
+/**
+ * Data shape for workflow step nodes (static structure)
+ */
+interface WorkflowStepNodeData {
+    id: string;
+    name: string;
+    description: string;
+    isEntryPoint: boolean;
+    isEndNode: boolean;
+    isConditional: boolean;
+    routeCount?: number;
+    [key: string]: unknown;
+}
+/**
+ * Data shape for workflow step edges (static structure)
+ */
+interface WorkflowStepEdgeData {
+    edgeType: WorkflowEdgeType;
+    label?: string;
+    [key: string]: unknown;
+}
+/**
+ * Agent iteration status type (alias for shared ExecutionStatus)
+ */
+type AgentStatus = ExecutionStatus;
+interface AgentIterationNodeData {
+    nodeType: 'initialization' | 'iteration' | 'completion';
+    label?: string;
+    iterationNumber?: number;
+    status: AgentStatus;
+    reasoningCount?: number;
+    actionCount?: number;
+    duration?: number;
+    isLive: boolean;
+}
+interface AgentIterationEdgeData {
+    sourceStatus: AgentStatus;
+    targetStatus: AgentStatus;
+}
+
+/**
+ * useWorkflowStepsLayout - Hook to convert workflow definition to ReactFlow nodes/edges
+ *
+ * Uses Dagre for automatic graph layout:
+ * - Left-to-right flow (LR)
+ * - Minimizes edge crossings
+ * - Keeps connected nodes closer together
+ */
+
+/**
+ * Serialized next config from API
+ */
+interface SerializedNextConfig {
+    type: 'linear' | 'conditional';
+    target?: string;
+    routes?: Array<{
+        target: string;
+    }>;
+    default?: string;
+}
+/**
+ * Serialized workflow step from API
+ */
+interface SerializedWorkflowStep {
+    id: string;
+    name: string;
+    description: string;
+    next: SerializedNextConfig | null;
+}
+/**
+ * Serialized workflow definition subset needed for layout
+ */
+interface WorkflowStepsLayoutInput {
+    entryPoint: string;
+    steps: SerializedWorkflowStep[];
+}
+/**
+ * Hook to convert workflow definition to React Flow nodes and edges with Dagre layout
+ *
+ * @returns nodes, edges, and calculated graphHeight for dynamic container sizing
+ */
+declare function useWorkflowStepsLayout(workflow: WorkflowStepsLayoutInput | undefined): {
+    nodes: Node<WorkflowStepNodeData>[];
+    edges: Edge<WorkflowStepEdgeData>[];
+    graphHeight: number;
+};
+
+/**
+ * useUnifiedWorkflowLayout - Merge Dagre layout with execution state
+ *
+ * Combines static workflow structure (positioned nodes/edges from Dagre) with
+ * real-time execution state (status, dimming, taken paths) to produce unified
+ * visualization data for the UnifiedWorkflowGraph component.
+ */
+
+/**
+ * Hook to merge workflow structure layout with execution state
+ */
+declare function useUnifiedWorkflowLayout(workflow: WorkflowStepsLayoutInput | undefined, executionPath: ExecutionPathState | undefined, selectedStepId?: string | null, mode?: GraphMode): {
+    nodes: Node<UnifiedWorkflowNodeData>[];
+    edges: Edge<UnifiedWorkflowEdgeData>[];
+    graphHeight: number;
+};
+
+/**
+ * useReactFlowAgent Hook
+ *
+ * Converts agent iteration data into ReactFlow nodes and edges for visualization.
+ */
+
+declare function useReactFlowAgent(iterationData: AgentIterationData | null, _resourceDefinition: SerializedAgentDefinition | undefined, selectedIterationId: number | 'initialization' | 'completion' | null, liveExecutions: Set<string>, selectedExecutionId?: string): {
+    nodes: Node[];
+    edges: Edge[];
+};
+
+/**
+ * Unified status color system for execution visualizers
+ * Shared between workflow and agent implementations
+ */
+
+interface StatusColorScheme {
+    color: string;
+    badge: string;
+}
+/**
+ * Status color mappings using CSS variables for theme-aware colors
+ * Simplified: one color for all visual elements (icon, border, selection)
+ */
+declare const STATUS_COLORS: Record<ExecutionStatus, StatusColorScheme>;
+/**
+ * Get status colors for a given execution status
+ */
+declare function getStatusColors(status: ExecutionStatus): StatusColorScheme;
+
+interface ExecutionStatusBadgeProps {
+    /** The execution status */
+    status: ExecutionStatus;
+    /** Badge size - defaults to 'sm' */
+    size?: BadgeProps['size'];
+    /** Badge variant - defaults to 'light' */
+    variant?: 'light' | 'filled' | 'outline' | 'dot';
+    /** Whether to show a loader for running status - defaults to true */
+    showLoader?: boolean;
+}
+/**
+ * ExecutionStatusBadge - Reusable badge for execution statuses
+ *
+ * Consolidates status badge rendering across:
+ * - ExecutionSummaryRow.tsx
+ * - SessionExecutionLogs.tsx
+ * - BaseExecutionLogsHeader.tsx
+ * - UnifiedWorkflowNode.tsx
+ * - Dashboard.tsx task list
+ *
+ * Uses the centralized STATUS_COLORS from statusColors.ts
+ *
+ * @example
+ * ```tsx
+ * <ExecutionStatusBadge status="running" />
+ * <ExecutionStatusBadge status="completed" variant="dot" />
+ * ```
+ */
+declare function ExecutionStatusBadge({ status, size, variant, showLoader }: ExecutionStatusBadgeProps): react_jsx_runtime.JSX.Element;
+
+interface ExecutionStatsProps {
+    totalExecutions: number;
+    successCount: number;
+    failureCount: number;
+    warningCount?: number;
+    successRate: number;
+    align?: 'flex-start' | 'flex-end' | 'center';
+    /** Compact mode renders metric chips in a horizontal row */
+    compact?: boolean;
+}
+/**
+ * Execution statistics with colored text — vertical stack or compact metric chips
+ */
+declare function ExecutionStats({ totalExecutions, successCount, failureCount, warningCount, successRate, align, compact }: ExecutionStatsProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * TimelineContainer Component
+ *
+ * Outer container for the timeline visualization.
+ * Wraps timeline rows and displays time axis at the bottom.
+ */
+declare function TimelineContainer({ executionStart, executionEnd, children }: TimelineContainerProps): react_jsx_runtime.JSX.Element;
+
+interface TimelineAxisProps {
+    totalDuration: number;
+}
+/**
+ * TimelineAxis Component
+ *
+ * Renders time markers at the bottom of the timeline.
+ * Shows 0ms on the left, total duration on the right, and 3 intermediate markers.
+ */
+declare function TimelineAxis({ totalDuration }: TimelineAxisProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * TimelineBar Component
+ *
+ * Renders a single horizontal bar in the timeline visualization.
+ * Position and width are calculated as percentages based on absolute timestamps.
+ */
+declare function TimelineBar({ startTime, endTime, executionStart, executionEnd, status, label, onClick, isSelected, hasSelection }: TimelineBarProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * TimelineRow Component
+ *
+ * Renders a row in the timeline with a label and one or more timeline bars.
+ * Supports indentation for nested rows (e.g., sub-activities within iterations).
+ */
+declare function TimelineRow({ label, bars, executionStart, executionEnd, indent, selectedNodeId }: TimelineRowProps): react_jsx_runtime.JSX.Element;
+
+interface IVisualizerContainerProps {
+    children: React.ReactNode;
+    /** Click handler for container (for deselecting nodes). Optional for definition mode. */
+    handleContainerClick?: (event: React.MouseEvent) => void;
+    /** Optional dynamic height calculated from graph layout. Falls back to default if not provided. */
+    height?: number;
+}
+declare const VisualizerContainer: ({ children, handleContainerClick, height }: IVisualizerContainerProps) => react_jsx_runtime.JSX.Element;
+
+declare const EmptyVisualizer: ({ message }: {
+    message?: string;
+}) => react_jsx_runtime.JSX.Element;
+
+interface UnifiedWorkflowGraphProps {
+    /**
+     * Workflow definition (entry point, steps, routes)
+     * Accepts either SerializedWorkflowDefinition (execution mode) or WorkflowStepsLayoutInput (definition mode)
+     */
+    resourceDefinition: SerializedWorkflowDefinition | WorkflowStepsLayoutInput;
+    /** Execution logs from SSE or useExecution hook (only used in execution mode) */
+    executionLogs?: ExecutionLogMessage[];
+    /** Currently selected step ID for highlighting (only used in execution mode) */
+    selectedStepId?: string | null;
+    /** Callback when step selection changes (only used in execution mode) */
+    onStepSelect?: (stepId: string | null) => void;
+    /** External trigger for fit view (increment to trigger, used after collapse animations) */
+    fitViewTrigger?: number;
+}
+declare function UnifiedWorkflowGraph({ resourceDefinition, executionLogs, selectedStepId, onStepSelect, fitViewTrigger: externalFitViewTrigger }: UnifiedWorkflowGraphProps): react_jsx_runtime.JSX.Element;
+
+type UnifiedWorkflowNodeProps = NodeProps<Node<UnifiedWorkflowNodeData>>;
+declare const UnifiedWorkflowNode: react.NamedExoticComponent<UnifiedWorkflowNodeProps>;
+
+type UnifiedWorkflowEdgeProps = EdgeProps<Edge<UnifiedWorkflowEdgeData, string>>;
+declare const UnifiedWorkflowEdge: react.NamedExoticComponent<UnifiedWorkflowEdgeProps>;
+
+interface WorkflowExecutionTimelineProps {
+    timelineData: WorkflowNodeVisualizerData;
+    selectedStepId?: string | null;
+}
+/**
+ * WorkflowExecutionTimeline Component
+ *
+ * Renders a Temporal-style timeline visualization for workflow executions.
+ * Shows all workflow steps with their timing and status.
+ */
+declare function WorkflowExecutionTimeline({ timelineData, selectedStepId }: WorkflowExecutionTimelineProps): react_jsx_runtime.JSX.Element;
+
+interface AgentExecutionVisualizerProps {
+    resourceDefinition: SerializedAgentDefinition;
+    iterationData: AgentIterationData | null;
+    selectedExecutionId?: string;
+    liveExecutions: Set<string>;
+    selectedIterationId: number | 'initialization' | 'completion' | null;
+    onIterationSelect: (iterationId: number | 'initialization' | 'completion' | null) => void;
+}
+declare function AgentExecutionVisualizer({ resourceDefinition, iterationData, selectedExecutionId, liveExecutions, selectedIterationId, onIterationSelect }: AgentExecutionVisualizerProps): react_jsx_runtime.JSX.Element;
+
+interface AgentExecutionTimelineProps {
+    iterationData: AgentIterationData;
+    selectedIterationId?: number | 'initialization' | 'completion' | null;
+}
+/**
+ * AgentExecutionTimeline Component
+ *
+ * Renders a Temporal-style timeline visualization for agent executions.
+ * Shows initialization, iterations (with sub-activities), and completion phases.
+ */
+declare function AgentExecutionTimeline({ iterationData, selectedIterationId }: AgentExecutionTimelineProps): react_jsx_runtime.JSX.Element;
+
+declare const AgentIterationNode: react.NamedExoticComponent<NodeProps>;
+
+declare const AgentIterationEdge: react.NamedExoticComponent<EdgeProps>;
+
+/**
+ * Timeline visualization constants
+ * Layout and styling constants for timeline components
+ */
+declare const TIMELINE_CONSTANTS: {
+    readonly BAR_HEIGHT: 24;
+    readonly ROW_GAP: 8;
+    readonly MIN_BAR_WIDTH_PERCENT: 0.5;
+    readonly LABEL_WIDTH: 200;
+    readonly INDENT_SIZE: 16;
+    readonly CONTAINER_PADDING: 16;
+    readonly CONTAINER_BORDER_RADIUS: 8;
+};
+/**
+ * Shared visualization constants used by both workflow and agent visualizers
+ */
+declare const SHARED_VIZ_CONSTANTS: {
+    readonly NODE_WIDTH: 160;
+    readonly NODE_SPACING: 220;
+    readonly HANDLE_SIZE: 8;
+    readonly MIN_ZOOM: 0.5;
+    readonly MAX_ZOOM: 2;
+};
+/**
+ * Container height constant (used by VisualizerContainer and EmptyVisualizer)
+ */
+declare const CONTAINER_CONSTANTS: {
+    CONTAINER_HEIGHT: number;
+};
+/**
+ * Agent-specific dimension and layout constants
+ */
+declare const AGENT_CONSTANTS: {
+    readonly NODE_HEIGHT: 140;
+    readonly CONTAINER_HEIGHT: 430;
+    readonly FIT_VIEW_PADDING: 0.2;
+    readonly ICON_SIZE: 16;
+    readonly STATUS_ICON_SIZE: 16;
+    readonly CIRCLE_SIZE: 40;
+    readonly PULSE_DURATION: "2s";
+    readonly TRANSITION_DURATION: "0.2s";
+    readonly NODE_WIDTH: 160;
+    readonly NODE_SPACING: 220;
+    readonly HANDLE_SIZE: 8;
+    readonly MIN_ZOOM: 0.5;
+    readonly MAX_ZOOM: 2;
+};
+declare const WORKFLOW_CONSTANTS: {
+    readonly FIT_VIEW_PADDING: 0.4;
+    readonly ICON_SIZE: 20;
+    readonly CIRCLE_SIZE: 40;
+    readonly SPIN_DURATION: "1s";
+    readonly NODE_WIDTH: 160;
+    readonly NODE_SPACING: 220;
+    readonly HANDLE_SIZE: 8;
+    readonly MIN_ZOOM: 0.5;
+    readonly MAX_ZOOM: 2;
+};
+
+/**
+ * Format duration in milliseconds for display
+ *
+ * @param ms - Duration in milliseconds
+ * @returns Formatted duration string (e.g., "150ms", "2.5s")
+ */
+declare function formatDuration(ms?: number): string;
+
+interface StatusIconColors {
+    icon: string;
+}
+interface GetStatusIconOptions {
+    status: ExecutionStatus;
+    colors: StatusIconColors;
+    iconSize: number;
+    spinDuration?: string;
+}
+/**
+ * Get status icon component for execution nodes
+ *
+ * @param options - Configuration for icon rendering
+ * @returns React component for the status icon
+ */
+declare function getStatusIcon({ status, colors, iconSize, spinDuration }: GetStatusIconOptions): react_jsx_runtime.JSX.Element;
+
+/**
+ * Get the color for a resource status badge
+ * @param resourceStatus - The resource status ('dev' | 'prod')
+ * @returns CSS variable color string
+ */
+declare function getResourceStatusColor(resourceStatus: ResourceStatus): string;
+
+interface EdgeColorOptions {
+    selected?: boolean;
+    sourceStatus: ExecutionStatus;
+}
+/**
+ * Get edge color based on source node status
+ * Simplified: uses unified status color system
+ */
+declare function getEdgeColor({ selected, sourceStatus }: EdgeColorOptions): string;
+interface EdgeOpacityOptions {
+    sourceStatus: ExecutionStatus;
+}
+/**
+ * Get edge opacity based on source node status
+ */
+declare function getEdgeOpacity({ sourceStatus }: EdgeOpacityOptions): number;
+/**
+ * Check if edge should be animated (when source or target is running)
+ */
+declare function shouldAnimateEdge(sourceStatus: ExecutionStatus, targetStatus: ExecutionStatus): boolean;
+
+/**
+ * Calculate timeline bar position and width as percentages
+ *
+ * Handles edge cases:
+ * - Zero duration executions (instant completion)
+ * - Activities that start before execution (data inconsistency)
+ * - Activities that extend beyond execution end (data inconsistency)
+ * - Zero or near-zero duration activities (enforces minimum visible width)
+ *
+ * @param startTime - Activity start timestamp (absolute)
+ * @param endTime - Activity end timestamp (absolute)
+ * @param executionStart - Execution start timestamp (absolute)
+ * @param executionEnd - Execution end timestamp (absolute)
+ * @returns Object with left and width percentages for bar positioning
+ */
+declare function calculateBarPosition(startTime: number, endTime: number, executionStart: number, executionEnd: number): {
+    left: number;
+    width: number;
+};
+
+export { AGENT_CONSTANTS, AgentExecutionTimeline, AgentExecutionVisualizer, AgentIterationEdge, AgentIterationNode, CONTAINER_CONSTANTS, EmptyVisualizer, ExecutionStats, ExecutionStatusBadge, SHARED_VIZ_CONSTANTS, STATUS_COLORS, TIMELINE_CONSTANTS, TimelineAxis, TimelineBar, TimelineContainer, TimelineRow, UnifiedWorkflowEdge, UnifiedWorkflowGraph, UnifiedWorkflowNode, VisualizerContainer, WORKFLOW_CONSTANTS, WorkflowExecutionTimeline, calculateBarPosition, formatDuration, getEdgeColor, getEdgeOpacity, getResourceStatusColor, getStatusColors, getStatusIcon, shouldAnimateEdge, useAgentIterationData, useExecutionPath, useMergedExecution, useReactFlowAgent, useTimelineData, useUnifiedWorkflowLayout, useWorkflowStepsLayout };
+export type { AgentIterationEdgeData, AgentIterationNodeData, AgentStatus, EdgeColorOptions, EdgeOpacityOptions, ExecutionPathState, ExecutionStatus, GraphMode, StatusColorScheme, StatusIconColors, StepExecutionData, TimelineBarProps, TimelineContainerProps, TimelineRowProps, UnifiedWorkflowEdgeData, UnifiedWorkflowNodeData, WorkflowEdgeType, WorkflowStepEdgeData, WorkflowStepNodeData, WorkflowStepsLayoutInput };