@invect/ui 0.0.1

package/dist/components/flow-editor/node-config-panel/panels/ConfigurationPanel.d.ts

@@ -0,0 +1,49 @@
+import { AgentToolsPanelProps } from './AgentToolsPanel';
+import { Credential } from '../../../../api/types';
+import { NodeParamField } from '../../../../types/node-definition.types';
+interface NodeDefinition {
+    paramFields?: NodeParamField[];
+}
+interface ConfigurationPanelProps {
+    definition: NodeDefinition | undefined;
+    formValues: Record<string, unknown>;
+    onFieldChange: (fieldName: string, value: unknown) => void;
+    credentials: Credential[];
+    credentialsLoading: boolean;
+    credentialsError: boolean;
+    onRefreshCredentials: () => void;
+    onAddNewCredential: (fieldName: string) => void;
+    onEditCredential?: (credential: Credential) => void;
+    onRefreshOAuthCredential?: (credential: Credential) => void;
+    refreshingCredentialId?: string | null;
+    configWarnings: string[];
+    configErrors: string[];
+    runError: string | null;
+    /** Per-field validation errors keyed by field name (from execution errors). */
+    fieldErrors?: Record<string, string>;
+    nodeType: string;
+    modelStatusMessage: string;
+    portalContainer?: HTMLElement | null;
+    /**
+     * Available upstream node reference IDs for loop variable suggestions
+     */
+    upstreamVariables?: string[];
+    /** Input data from upstream nodes — for autocomplete in code fields. */
+    inputData?: Record<string, unknown>;
+    /** Node header props — rendered as the panel header */
+    headerLabel?: string;
+    onHeaderLabelChange?: (value: string) => void;
+    headerNodeTypeLabel?: string;
+    HeaderIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    headerCategoryColor?: string;
+    onRunNode?: () => void;
+    runButtonLabel?: string;
+    runDisabled?: boolean;
+    isRunning?: boolean;
+    /** Agent tools props — only provided when nodeType is AGENT */
+    agentTools?: Omit<AgentToolsPanelProps, 'portalContainer'>;
+}
+export declare function ConfigurationPanel({ definition, formValues, onFieldChange, credentials, credentialsLoading, credentialsError, onRefreshCredentials, onAddNewCredential, onEditCredential, onRefreshOAuthCredential, refreshingCredentialId, configWarnings, configErrors, runError, fieldErrors, nodeType, modelStatusMessage, portalContainer, upstreamVariables: _upstreamVariables, inputData, headerLabel, onHeaderLabelChange, headerNodeTypeLabel, HeaderIcon, headerCategoryColor, onRunNode, runButtonLabel, runDisabled, isRunning, agentTools, }: ConfigurationPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/flow-editor/node-config-panel/panels/DataMapperPane.d.ts

@@ -0,0 +1,40 @@
+interface MapperConfig {
+    enabled: boolean;
+    expression: string;
+    mode: 'auto' | 'iterate' | 'reshape';
+    outputMode: 'array' | 'object' | 'first' | 'last' | 'concat';
+    keyField?: string;
+    concurrency: number;
+    onEmpty: 'skip' | 'error';
+}
+interface MapperPreviewResult {
+    success: boolean;
+    result?: unknown;
+    resultType?: 'array' | 'object' | 'primitive';
+    itemCount?: number;
+    error?: string;
+}
+interface DataMapperPaneProps {
+    /** Current mapper config from form state */
+    value: MapperConfig | undefined;
+    /** Called when any mapper field changes */
+    onChange: (config: MapperConfig | undefined) => void;
+    /** Available upstream variable names (for hints) */
+    availableVariables?: string[];
+    /** Callback to test the mapper expression against live data */
+    onTestMapper?: (request: {
+        expression: string;
+        incomingData: Record<string, unknown>;
+        mode?: 'auto' | 'iterate' | 'reshape';
+    }) => void;
+    /** Result from the last test */
+    previewResult?: MapperPreviewResult | null;
+    /** Whether test is in progress */
+    isTestingMapper?: boolean;
+    /** Current input data JSON for passing to the test API */
+    inputData?: Record<string, unknown>;
+    /** Portal container for dropdowns */
+    portalContainer?: HTMLElement | null;
+}
+export declare function DataMapperPane({ value, onChange, availableVariables, onTestMapper, previewResult, isTestingMapper, inputData, portalContainer: _portalContainer, }: DataMapperPaneProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/flow-editor/node-config-panel/panels/InputPanel.d.ts

@@ -0,0 +1,49 @@
+import { UpstreamSlot } from '../types';
+interface MapperConfig {
+    enabled: boolean;
+    expression: string;
+    mode: 'auto' | 'iterate' | 'reshape';
+    outputMode: 'array' | 'object' | 'first' | 'last' | 'concat';
+    keyField?: string;
+    concurrency: number;
+    onEmpty: 'skip' | 'error';
+}
+interface MapperPreviewResult {
+    success: boolean;
+    result?: unknown;
+    resultType?: 'array' | 'object' | 'primitive';
+    itemCount?: number;
+    error?: string;
+}
+interface InputPanelProps {
+    value: string;
+    onChange: (value: string) => void;
+    error: string | null;
+    isTestMode: boolean;
+    onReset: () => void;
+    /** Upstream slot metadata for inline run controls */
+    upstreamSlots?: UpstreamSlot[];
+    /** Called when user clicks the run/retry button for a slot */
+    onRunSlot?: (slot: UpstreamSlot) => void;
+    /** Run all unresolved slots */
+    onRunAll?: () => void;
+    /** Number of unresolved slots */
+    unresolvedCount?: number;
+    /** Whether any slot is currently loading */
+    isAnyLoading?: boolean;
+    /** Data mapper props */
+    mapperValue?: MapperConfig;
+    onMapperChange?: (config: MapperConfig | undefined) => void;
+    mapperAvailableVariables?: string[];
+    onTestMapper?: (request: {
+        expression: string;
+        incomingData: Record<string, unknown>;
+        mode?: 'auto' | 'iterate' | 'reshape';
+    }) => void;
+    mapperPreviewResult?: MapperPreviewResult | null;
+    isTestingMapper?: boolean;
+    mapperInputData?: Record<string, unknown>;
+    portalContainer?: HTMLElement | null;
+}
+export declare function InputPanel({ value, onChange, error, isTestMode, onReset, upstreamSlots, onRunSlot, onRunAll, unresolvedCount, isAnyLoading, mapperValue, onMapperChange, mapperAvailableVariables, onTestMapper, mapperPreviewResult, isTestingMapper, mapperInputData, portalContainer, }: InputPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/flow-editor/node-config-panel/panels/OutputPanel.d.ts

@@ -0,0 +1,7 @@
+interface OutputPanelProps {
+    value: string;
+    onChange: (value: string) => void;
+    error: string | null;
+}
+export declare function OutputPanel({ value, onChange, error }: OutputPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/flow-editor/node-config-panel/panels/index.d.ts

@@ -0,0 +1,4 @@
+export { InputPanel } from './InputPanel';
+export { OutputPanel } from './OutputPanel';
+export { ConfigurationPanel } from './ConfigurationPanel';
+export { AgentToolsPanel, type AgentToolsPanelProps } from './AgentToolsPanel';

package/dist/components/flow-editor/node-config-panel/types.d.ts

@@ -0,0 +1,19 @@
+export type UpstreamSlotStatus = 'idle' | 'loading' | 'resolved' | 'error';
+export interface UpstreamSlot {
+    /** The JSON key used in the input preview (reference_id or generated slug) */
+    key: string;
+    /** The real React Flow node ID — used for the API call */
+    sourceNodeId: string;
+    /** Human-readable label shown on hover / in tooltips */
+    sourceLabel: string;
+    /** The action type string (e.g. "core.model", "gmail.send_message") */
+    sourceType: string;
+    /** Lucide icon name for the node type (e.g. "Brain", "Mail") */
+    sourceIcon?: string;
+    /** Current state of this slot */
+    status: UpstreamSlotStatus;
+    /** The resolved output value, or null if not yet produced */
+    output: unknown;
+    /** Error message if execution failed */
+    error: string | null;
+}

package/dist/components/flow-editor/node-config-panel/use-node-config-panel-store.d.ts

@@ -0,0 +1,49 @@
+import { FlowRunResult } from '@invect/core/types';
+/**
+ * State for the node config panel
+ */
+interface NodeConfigPanelState {
+    nodeId: string | null;
+    flowId: string | null;
+    inputPreview: string;
+    outputPreview: string;
+    inputError: string | null;
+    outputError: string | null;
+    isTestMode: boolean;
+    originalInputPreview: string | null;
+    isRunningNode: boolean;
+    runError: string | null;
+    isCreateCredentialOpen: boolean;
+    activeCredentialField: string | null;
+}
+/**
+ * Actions for the node config panel
+ */
+interface NodeConfigPanelActions {
+    initializeForNode: (nodeId: string, flowId: string, initialInput: string, initialOutput: string) => void;
+    reset: () => void;
+    setInputPreview: (value: string) => void;
+    setInputError: (error: string | null) => void;
+    setOutputPreview: (value: string) => void;
+    setOutputError: (error: string | null) => void;
+    enterTestMode: () => void;
+    exitTestMode: () => void;
+    resetTestMode: () => void;
+    setIsRunningNode: (isRunning: boolean) => void;
+    setRunError: (error: string | null) => void;
+    openCreateCredentialModal: (fieldName: string) => void;
+    closeCreateCredentialModal: () => void;
+    handleTestModeSuccess: (output: unknown) => void;
+    handleNormalModeSuccess: (result: FlowRunResult, nodeId: string, updateNodeData: (nodeId: string, data: Record<string, unknown>) => void) => void;
+    handleExecutionError: (error: string) => void;
+}
+type NodeConfigPanelStore = NodeConfigPanelState & NodeConfigPanelActions;
+/**
+ * Zustand store for node config panel state management
+ */
+export declare const useNodeConfigPanelStore: import('zustand').UseBoundStore<import('zustand').StoreApi<NodeConfigPanelStore>>;
+/**
+ * Hook to get parsed input data for test mode execution
+ */
+export declare function useParsedInputPreview(): Record<string, unknown>;
+export {};

package/dist/components/flow-editor/node-config-panel/use-node-config-state.d.ts

@@ -0,0 +1,26 @@
+import { Node } from '@xyflow/react';
+import { NodeDefinition } from '../../../types/node-definition.types';
+interface UseNodeConfigStateOptions {
+    node: Node<Record<string, unknown>> | null;
+    nodeType: string;
+    definition?: NodeDefinition;
+    /** Callback to persist params back to Zustand. Required for backend resolution writes. */
+    onParamsChange?: (nodeId: string, params: Record<string, unknown>) => void;
+}
+interface UseNodeConfigStateResult {
+    definition?: NodeDefinition;
+    values: Record<string, unknown>;
+    warnings: string[];
+    errors: string[];
+    updateField: (fieldName: string, value: unknown) => void;
+    isUpdating: boolean;
+}
+/**
+ * Hook for node configuration state — reads params from the node (Zustand)
+ * and provides validation, backend config resolution, and field update.
+ *
+ * After Phase 1.3 refactor: `values` is derived from node.data.params (Zustand),
+ * NOT stored locally. This eliminates the dual-source-of-truth problem.
+ */
+export declare function useNodeConfigState({ node, nodeType, definition, onParamsChange, }: UseNodeConfigStateOptions): UseNodeConfigStateResult;
+export {};

package/dist/components/flow-editor/node-config-panel/use-run-node.d.ts

@@ -0,0 +1,16 @@
+import { GraphNodeType } from '@invect/core/types';
+interface UseRunNodeOptions {
+    nodeId: string | null;
+    flowId: string;
+    nodeType: GraphNodeType;
+    nodeParams: Record<string, unknown>;
+    updateNodeData: (nodeId: string, data: Record<string, unknown>) => void;
+}
+/**
+ * Hook that handles all node execution logic (both test mode and normal mode)
+ */
+export declare function useRunNode({ nodeId, flowId, nodeType, nodeParams, updateNodeData, }: UseRunNodeOptions): {
+    runNode: () => Promise<void>;
+    isRunningNode: boolean;
+};
+export {};

package/dist/components/flow-editor/node-config-panel/utils.d.ts

@@ -0,0 +1,9 @@
+export declare const getIconComponent: (iconName?: string) => any;
+export declare const formatNodeTypeLabel: (value: string) => string;
+export declare const stringifyJson: (value: unknown) => string;
+export declare const parseJson: (raw: string, setError: (value: string | null) => void) => Record<string, unknown> | null;
+/**
+ * Extract the primary output value from the structured node output format.
+ * Handles the `{ data: { variables: { output: { value } } } }` wrapper.
+ */
+export declare function extractOutputValue(nodeOutput: unknown): unknown;

package/dist/components/flow-editor/serialize-to-sdk.d.ts

@@ -0,0 +1,20 @@
+import { ClipboardNode, ClipboardEdge } from './use-copy-paste.types';
+/**
+ * Convert clipboard nodes and edges into SDK source code text.
+ *
+ * Returns a string like:
+ * ```
+ * // Nodes
+ * input('query', { variableName: 'query' }),
+ *
+ * model('answer', {
+ *   credentialId: 'cred-abc',
+ *   model: 'gpt-4o-mini',
+ *   prompt: '{{ query }}',
+ * }),
+ *
+ * // Edges
+ * ['query', 'answer'],
+ * ```
+ */
+export declare function serializeToSDK(nodes: ClipboardNode[], edges: ClipboardEdge[]): string;

package/dist/components/flow-editor/toolbar-context.d.ts

@@ -0,0 +1,2 @@
+export declare const ToolbarCollapsedProvider: import('react').Provider<boolean>;
+export declare function useToolbarCollapsed(): boolean;

package/dist/components/flow-editor/use-copy-paste.d.ts

@@ -0,0 +1,7 @@
+import { ReactFlowInstance } from '@xyflow/react';
+interface UseCopyPasteOptions {
+    flowId: string;
+    reactFlowInstance: ReactFlowInstance | null;
+}
+export declare function useCopyPaste({ flowId, reactFlowInstance }: UseCopyPasteOptions): void;
+export {};

package/dist/components/flow-editor/use-copy-paste.types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared types for the copy-paste system.
+ *
+ * Extracted so both `use-copy-paste.ts` and `serialize-to-sdk.ts` can
+ * reference the same clipboard payload shapes without circular imports.
+ */
+export interface ClipboardData {
+    sourceFlowId: string;
+    nodes: ClipboardNode[];
+    edges: ClipboardEdge[];
+    copyTime: number;
+}
+export interface ClipboardNode {
+    originalId: string;
+    type: string;
+    relativePosition: {
+        x: number;
+        y: number;
+    };
+    absolutePosition?: {
+        x: number;
+        y: number;
+    };
+    data: {
+        display_name: string;
+        reference_id: string;
+        params: Record<string, unknown>;
+        mapper?: unknown;
+        _loop?: unknown;
+    };
+}
+export interface ClipboardEdge {
+    originalId: string;
+    source: string;
+    target: string;
+    sourceHandle?: string | null;
+    targetHandle?: string | null;
+}

package/dist/components/flow-editor/use-flow-editor.d.ts

@@ -0,0 +1,44 @@
+import { Node, Edge } from '@xyflow/react';
+import { LayoutDirection } from './flow-editor.store';
+import { LayoutAlgorithm } from '../../utils/layoutUtils';
+interface UseFlowEditorOptions {
+    flowId: string;
+    version?: string;
+    basePath?: string;
+}
+/**
+ * Main hook that wires React Query with Zustand for the flow editor.
+ *
+ * React Query handles:
+ * - Fetching flow data from the server
+ * - Caching and background refetching
+ * - Mutation (save) operations
+ *
+ * Zustand handles:
+ * - Local node/edge state (working copy)
+ * - Dirty tracking
+ * - Selection state
+ * - UI state (panels, layout)
+ */
+export declare function useFlowEditor({ flowId, version, basePath }: UseFlowEditorOptions): {
+    flowId: string;
+    flowName: string;
+    nodes: Node[];
+    edges: Edge[];
+    isActive: boolean | undefined;
+    isLoading: boolean;
+    error: string | null;
+    isDirty: boolean;
+    save: (options?: {
+        skipSuccessToast?: boolean;
+    }) => Promise<boolean>;
+    execute: () => Promise<void>;
+    isSaving: boolean;
+    isExecuting: boolean;
+    currentLayout: LayoutAlgorithm;
+    layoutDirection: LayoutDirection;
+    applyLayout: (algorithm?: LayoutAlgorithm, direction?: LayoutDirection) => Promise<void>;
+    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<import('@invect/core/types').ReactFlowData, Error>>;
+    store: import('./flow-editor.store').FlowEditorStore;
+};
+export {};

package/dist/components/flow-runs-table/FlowRunsTable.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+interface FlowRunsTableProps {
+    basePath?: string;
+}
+export declare const FlowRunsTable: React.FC<FlowRunsTableProps>;
+export {};

package/dist/components/flow-runs-table/index.d.ts

@@ -0,0 +1 @@
+export { FlowRunsTable } from './FlowRunsTable';

package/dist/components/flow-viewer/FlowRunsView.d.ts

@@ -0,0 +1,7 @@
+export interface FlowRunsViewProps {
+    flowId: string;
+    flowVersion?: string;
+    basePath?: string;
+}
+export declare function FlowRunsView({ flowId, flowVersion, basePath }: FlowRunsViewProps): import("react/jsx-runtime").JSX.Element;
+export default FlowRunsView;

package/dist/components/flow-viewer/FlowStatusView.d.ts

@@ -0,0 +1,21 @@
+import { FlowRun } from '@invect/core/types';
+interface FlowStatusViewProps {
+    flowId: string;
+    flowVersion?: string;
+    basePath?: string;
+    selectedRunId: string | null;
+    selectedRun: FlowRun | null | undefined;
+    logsExpanded: boolean;
+    onNodeClick?: (nodeId: string) => void;
+    onEditNode?: (nodeId: string) => void;
+    /** Node ID to focus/center on (only set on user-initiated selection) */
+    focusNodeId?: string | null;
+    /** Callback when focus animation completes */
+    onFocusComplete?: () => void;
+    /** Incrementing counter that triggers a recenter (e.g. after panel resize) */
+    recenterTrigger?: number;
+    /** Currently selected node ID in the execution logs (for resize recenter) */
+    selectedNodeId?: string | null;
+}
+export declare function FlowStatusView({ flowId, flowVersion, basePath: _basePath, selectedRunId, selectedRun, logsExpanded, onNodeClick, onEditNode, focusNodeId, onFocusComplete, recenterTrigger, selectedNodeId, }: FlowStatusViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/flow-viewer/RunSelector.d.ts

@@ -0,0 +1,13 @@
+export interface RunSelectorItem {
+    id: string;
+    status: string;
+    startedAt?: string | Date;
+    completedAt?: string | Date;
+}
+interface RunSelectorProps {
+    runs: RunSelectorItem[];
+    selectedRunId: string | null;
+    onSelectRun: (runId: string) => void;
+}
+export declare function RunSelector({ runs, selectedRunId, onSelectRun }: RunSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/flow-viewer/RunsSidebar.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+export interface RunListItem {
+    id: string;
+    status: string;
+    startedAt?: string | Date;
+    completedAt?: string | Date;
+}
+interface RunsSidebarProps {
+    runs: RunListItem[];
+    selectedRunId: string | null;
+    onSelectRun: (runId: string) => void;
+}
+export declare const RunsSidebar: React.FC<RunsSidebarProps>;
+export {};

package/dist/components/flow-viewer/agent-tool-executions-list.d.ts

@@ -0,0 +1,7 @@
+import { ExecutionLogToolCall, AgentExecutionMetadata } from './use-execution-log-data';
+interface AgentToolExecutionsListProps {
+    toolCalls: ExecutionLogToolCall[];
+    agentMetadata?: AgentExecutionMetadata;
+}
+export declare function AgentToolExecutionsList({ toolCalls, agentMetadata, }: AgentToolExecutionsListProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/flow-viewer/index.d.ts

@@ -0,0 +1 @@
+export { FlowStatusView } from './FlowStatusView';

package/dist/components/flow-viewer/logs-panel.d.ts

@@ -0,0 +1,18 @@
+import { ExecutionLogNode, SelectedExecutionAttempt } from './use-execution-log-data';
+import { RunSelectorItem } from './RunSelector';
+interface LogsPanelProps {
+    nodes: ExecutionLogNode[];
+    selectedAttempt: SelectedExecutionAttempt | null;
+    onSelectAttempt: (next: SelectedExecutionAttempt) => void;
+    isExpanded: boolean;
+    onToggle: () => void;
+    loading?: boolean;
+    /** Runs list for the run selector dropdown */
+    runs?: RunSelectorItem[];
+    /** Currently selected run ID */
+    selectedRunId?: string | null;
+    /** Callback when a run is selected from the dropdown */
+    onSelectRun?: (runId: string) => void;
+}
+export declare function LogsPanel({ nodes, selectedAttempt, onSelectAttempt, isExpanded, onToggle, loading, runs, selectedRunId, onSelectRun, }: LogsPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/flow-viewer/use-execution-log-data.d.ts

@@ -0,0 +1,113 @@
+import { NodeExecution, NodeExecutionStatus, ReactFlowNode, GraphNodeType, AgentFinishReason } from '@invect/core/types';
+/**
+ * Individual tool call executed by an AI Agent
+ */
+export interface ExecutionLogToolCall {
+    id: string;
+    toolId: string;
+    toolName: string;
+    input: Record<string, unknown>;
+    output?: unknown;
+    error?: string;
+    success: boolean;
+    iteration: number;
+    executionTimeMs: number;
+}
+/**
+ * Agent-specific metadata for execution attempts
+ */
+export interface AgentExecutionMetadata {
+    iterations: number;
+    finishReason: AgentFinishReason;
+    finalResponse: string;
+    model?: string;
+    provider?: string;
+    tokenUsage?: {
+        conversationTokensEstimate: number;
+        truncationOccurred: boolean;
+    };
+}
+export interface ExecutionLogAttempt {
+    id: string;
+    attemptNumber: number;
+    label: string;
+    status: NodeExecutionStatus;
+    startedAt?: string;
+    completedAt?: string;
+    durationMs?: number;
+    inputs?: Record<string, unknown>;
+    outputs?: NodeExecution['outputs'];
+    error?: string;
+    nodeExecutionId?: string;
+    /** Tool calls for agent nodes */
+    toolCalls?: ExecutionLogToolCall[];
+    /** Agent-specific metadata for agent nodes */
+    agentMetadata?: AgentExecutionMetadata;
+    /** True when this attempt is a loop/mapper iteration (detected via _item in inputs) */
+    isLoopIteration?: boolean;
+    /** The _item metadata for loop iterations */
+    iterationItem?: {
+        value: unknown;
+        index: number;
+        iteration: number;
+        first: boolean;
+        last: boolean;
+        total: number;
+    };
+}
+export interface ExecutionLogNode {
+    nodeId: string;
+    nodeName: string;
+    nodeType?: GraphNodeType | string;
+    latestStatus: NodeExecutionStatus;
+    attempts: ExecutionLogAttempt[];
+    definitionIndex: number;
+}
+export interface SelectedExecutionAttempt {
+    nodeId: string;
+    attemptId: string;
+    /** Optional: selected tool call ID within an agent node */
+    toolCallId?: string;
+}
+type UseExecutionLogDataParams = {
+    nodes?: ReactFlowNode[];
+    nodeExecutions?: NodeExecution[];
+};
+export declare function useExecutionLogData({ nodes, nodeExecutions }: UseExecutionLogDataParams): {
+    nodes: {
+        nodeId: string;
+        nodeName: string;
+        nodeType: string | undefined;
+        attempts: {
+            attemptNumber: number;
+            label: string;
+            id: string;
+            status: NodeExecutionStatus;
+            startedAt?: string;
+            completedAt?: string;
+            durationMs?: number;
+            inputs?: Record<string, unknown>;
+            outputs?: NodeExecution["outputs"];
+            error?: string;
+            nodeExecutionId?: string;
+            /** Tool calls for agent nodes */
+            toolCalls?: ExecutionLogToolCall[];
+            /** Agent-specific metadata for agent nodes */
+            agentMetadata?: AgentExecutionMetadata;
+            /** True when this attempt is a loop/mapper iteration (detected via _item in inputs) */
+            isLoopIteration?: boolean;
+            /** The _item metadata for loop iterations */
+            iterationItem?: {
+                value: unknown;
+                index: number;
+                iteration: number;
+                first: boolean;
+                last: boolean;
+                total: number;
+            };
+        }[];
+        latestStatus: NodeExecutionStatus;
+        definitionIndex: number;
+    }[];
+};
+export {};

package/dist/components/graph/BatchFlowEdge.d.ts

@@ -0,0 +1,33 @@
+import { default as React } from 'react';
+import { EdgeProps, MarkerType } from '@xyflow/react';
+export interface BatchFlowEdgeData extends Record<string, unknown> {
+    label?: string;
+    type?: 'default' | 'data' | 'conditional' | 'error' | 'skipped';
+    animated?: boolean;
+    highlighted?: boolean;
+    selected?: boolean;
+    sourceHandle?: string;
+    targetHandle?: string;
+    sourceNodeStatus?: string;
+    targetNodeStatus?: string;
+    validation?: {
+        valid: boolean;
+        message?: string;
+    };
+}
+export declare const BatchFlowEdge: React.NamedExoticComponent<EdgeProps>;
+export declare const defaultEdgeOptions: {
+    type: string;
+    animated: boolean;
+    style: {
+        strokeWidth: number;
+        stroke: string;
+        fill: string;
+    };
+    markerEnd: {
+        type: MarkerType;
+        width: number;
+        height: number;
+        color: string;
+    };
+};

package/dist/components/graph/LayoutSelector.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { LayoutAlgorithm } from '../../utils/layoutUtils';
+interface LayoutSelectorProps {
+    currentLayout: LayoutAlgorithm;
+    onLayoutChange: (layout: LayoutAlgorithm, direction?: 'TB' | 'BT' | 'LR' | 'RL') => void;
+    className?: string;
+}
+export declare const LayoutSelector: React.FC<LayoutSelectorProps>;
+export {};