@invect/ui 0.0.1

package/dist/components/credentials/OAuth2ConnectButton.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+import { OAuth2ProviderDefinition, Credential } from '../../api/types';
+export interface OAuth2ConnectButtonProps {
+    /** The OAuth2 provider to connect to */
+    provider: OAuth2ProviderDefinition;
+    /** OAuth2 client ID (from your app's OAuth configuration) */
+    clientId: string;
+    /** OAuth2 client secret (from your app's OAuth configuration) */
+    clientSecret: string;
+    /** Redirect URI registered with the OAuth provider */
+    redirectUri: string;
+    /** Optional: Custom scopes to request (defaults to provider's default scopes) */
+    scopes?: string[];
+    /** Optional: Custom name for the created credential */
+    credentialName?: string;
+    /** Called when credential is successfully created */
+    onSuccess?: (credential: Credential) => void;
+    /** Called when an error occurs */
+    onError?: (error: Error) => void;
+    /** Button variant */
+    variant?: 'default' | 'outline' | 'secondary' | 'ghost';
+    /** Button size */
+    size?: 'default' | 'sm' | 'lg' | 'icon';
+    /** Additional CSS classes */
+    className?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Children to render inside button (defaults to "Connect with {provider.name}") */
+    children?: React.ReactNode;
+}
+export declare function OAuth2ConnectButton({ provider, clientId, clientSecret, redirectUri, scopes, credentialName, onSuccess, onError, variant, size, className, disabled, children, }: OAuth2ConnectButtonProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * OAuth2 Callback Handler Component
+ *
+ * Place this component on your OAuth callback page.
+ * It extracts the code/state from URL and sends it to the parent window.
+ */
+export declare function OAuth2CallbackHandler(): import("react/jsx-runtime").JSX.Element;

package/dist/components/credentials/OAuth2ProviderSelector.d.ts

@@ -0,0 +1,15 @@
+import { Credential } from '../../api/types';
+interface OAuth2ProviderSelectorProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Called when a credential is successfully created */
+    onCredentialCreated?: (credential: Credential) => void;
+    /** Portal container for modals */
+    portalContainer?: HTMLElement | null;
+    /** Filter to only show specific providers by ID (e.g., ["google"]) */
+    filterProviders?: string[];
+    /** Override scopes for the OAuth flow (uses provider defaults if not set) */
+    scopes?: string[];
+}
+export declare function OAuth2ProviderSelector({ open, onOpenChange, onCredentialCreated, portalContainer, filterProviders, scopes, }: OAuth2ProviderSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/credentials/credential-utils.d.ts

@@ -0,0 +1,12 @@
+import { Credential, CredentialAuthType, CredentialType } from '../../api/types';
+export declare const AUTH_TYPE_CONFIG: Record<string, {
+    label: string;
+    color: string;
+}>;
+export declare const formatDate: (dateString?: string) => string;
+export declare const formatFullDate: (dateString?: string) => string;
+export declare function isTokenExpired(credential: Credential): boolean;
+export declare function getAuthTypesForType(type: CredentialType): {
+    value: CredentialAuthType;
+    label: string;
+}[];

package/dist/components/credentials/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Credentials Components
+ *
+ * Export all credential-related components.
+ */
+export { CreateCredentialModal } from './CreateCredentialModal';
+export { EditCredentialModal } from './EditCredentialModal';
+export { OAuth2ConnectButton, OAuth2CallbackHandler } from './OAuth2ConnectButton';
+export { OAuth2ProviderSelector } from './OAuth2ProviderSelector';

package/dist/components/dashboard/FailedRunsAlert.d.ts

@@ -0,0 +1,3 @@
+export declare function FailedRunsAlert({ basePath }: {
+    basePath: string;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/dashboard/FlowCard.d.ts

@@ -0,0 +1,7 @@
+import { Flow } from '@invect/core/types';
+interface FlowCardProps {
+    flow: Flow;
+    basePath: string;
+}
+export declare function FlowCard({ flow, basePath }: FlowCardProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/dashboard/RecentActivityTable.d.ts

@@ -0,0 +1,9 @@
+import { Flow, FlowRun } from '@invect/core/types';
+interface RecentActivityTableProps {
+    runs: FlowRun[];
+    flows: Flow[];
+    basePath: string;
+    isLoading: boolean;
+}
+export declare function RecentActivityTable({ runs, flows, basePath, isLoading, }: RecentActivityTableProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/dashboard/StatCard.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface StatCardProps {
+    title: string;
+    value: string | number;
+    subtitle?: string;
+    icon: React.ElementType;
+    className?: string;
+}
+export declare function StatCard({ title, value, subtitle, icon: Icon, className }: StatCardProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/dashboard/index.d.ts

@@ -0,0 +1,5 @@
+export { FailedRunsAlert } from './FailedRunsAlert';
+export { FlowCard } from './FlowCard';
+export { RecentActivityTable } from './RecentActivityTable';
+export { StatCard } from './StatCard';
+export { formatRelativeTime, formatDuration, StatusBadge } from './status-helpers';

package/dist/components/dashboard/status-helpers.d.ts

@@ -0,0 +1,5 @@
+export declare function formatRelativeTime(date: string | Date): string;
+export declare function formatDuration(ms: number): string;
+export declare function StatusBadge({ status }: {
+    status: string;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+import { NodeSidebarProps } from './NodeSidebar';
+export declare function ActionsSidebar({ onClose, onCollapse, availableTools, addedTools, onAddTool, onRemoveTool, onSelectTool, selectedInstanceId, }: NodeSidebarProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+export interface FlowEditorProps {
+    flowId: string;
+    flowVersion?: string;
+    basePath?: string;
+    initialName?: string;
+}
+export declare function FlowEditor({ flowId, flowVersion, basePath }: FlowEditorProps): import("react/jsx-runtime").JSX.Element;
+interface FlowWorkbenchViewProps {
+    flowId: string;
+    onRegisterAddNode?: (fn: (type: string) => void) => void;
+    onLayoutSelectorRender?: (layoutSelector: React.ReactNode) => void;
+    /** Callback to add a node (passed from shell, used for sidebar) */
+    onAddNode: (type: string) => void;
+    /** Renders the sidebar element (NodeSidebar with current mode + props) */
+    onSidebarRender: (sidebar: React.ReactNode) => void;
+    /** Renders the right panel element (ToolConfigPanel when active) */
+    onRightPanelRender: (rightPanel: React.ReactNode | null) => void;
+}
+export declare function FlowWorkbenchView({ flowId, onRegisterAddNode, onLayoutSelectorRender, onAddNode, onSidebarRender, onRightPanelRender, }: FlowWorkbenchViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+interface FlowHeaderProps {
+    flowName: string;
+    onFlowNameChange: (name: string) => void;
+    isDirty?: boolean;
+    onSave?: () => Promise<boolean | void>;
+    isSaving?: boolean;
+}
+export declare function FlowHeader({ flowName, onFlowNameChange, isDirty, onSave, isSaving, }: FlowHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+interface FlowLayoutProps {
+    sidebar: React.ReactNode;
+    viewport: React.ReactNode;
+    modeSwitcher: React.ReactNode;
+    layoutSelector?: React.ReactNode;
+    viewportRef?: React.RefObject<HTMLDivElement | null>;
+    /** Panel that appears on the right side (e.g. tool config, node config) */
+    rightPanel?: React.ReactNode;
+    /** Chat toggle button rendered in the top-right toolbar */
+    chatToggle?: React.ReactNode;
+    /** Chat panel rendered as a right sidebar */
+    chatPanel?: React.ReactNode;
+    /** Floating chat overlay rendered above the viewport (for empty flows) */
+    chatOverlay?: React.ReactNode;
+    /** Extra controls rendered in the bottom toolbar (e.g. Run button, Active/Inactive) */
+    toolbarExtra?: React.ReactNode;
+    /** Whether the sidebar is open */
+    sidebarOpen?: boolean;
+    /** Called to toggle sidebar visibility */
+    onToggleSidebar?: () => void;
+}
+export declare function FlowLayout({ sidebar, viewport, modeSwitcher, layoutSelector, viewportRef, rightPanel, chatToggle, chatPanel, chatOverlay, toolbarExtra, sidebarOpen, onToggleSidebar, }: FlowLayoutProps): import("react/jsx-runtime").JSX.Element;
+export default FlowLayout;

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

@@ -0,0 +1,7 @@
+export type ViewMode = 'edit' | 'runs';
+interface ModeSwitcherProps {
+    mode: ViewMode;
+    onModeChange: (mode: ViewMode) => void;
+}
+export declare function ModeSwitcher({ mode, onModeChange }: ModeSwitcherProps): import("react/jsx-runtime").JSX.Element;
+export default ModeSwitcher;

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

@@ -0,0 +1,24 @@
+import { ToolDefinition, AddedToolInstance } from '../nodes/ToolSelectorModal';
+export type SidebarMode = 'nodes' | 'actions';
+export interface NodeSidebarProps {
+    /** Current display mode */
+    mode: SidebarMode;
+    onAddNode: (type: string) => void;
+    /** Called to collapse/hide the sidebar */
+    onCollapse?: () => void;
+    /** Close the actions panel (returns to nodes mode) */
+    onClose?: () => void;
+    /** All available tools from API */
+    availableTools?: ToolDefinition[];
+    /** Currently added tool instances on the agent node */
+    addedTools?: AddedToolInstance[];
+    /** Called when a tool is added. Returns the new instance ID. */
+    onAddTool?: (toolId: string) => string;
+    /** Called when a tool instance is removed */
+    onRemoveTool?: (instanceId: string) => void;
+    /** Called when an added tool instance is clicked (to open config panel) */
+    onSelectTool?: (instance: AddedToolInstance) => void;
+    /** Currently selected instance (to highlight) */
+    selectedInstanceId?: string | null;
+}
+export declare function NodeSidebar(props: NodeSidebarProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,12 @@
+interface RunControlsProps {
+    onExecute?: () => Promise<void>;
+    isExecuting?: boolean;
+    isActive?: boolean;
+    isTogglingActive?: boolean;
+    onToggleActive?: () => void;
+}
+/**
+ * Run button + Active/Inactive toggle, rendered inside the bottom canvas toolbar.
+ */
+export declare function RunControls({ onExecute, isExecuting, isActive, isTogglingActive, onToggleActive, }: RunControlsProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,16 @@
+import { ToolDefinition, AddedToolInstance } from '../nodes/ToolSelectorModal';
+export interface ToolConfigPanelProps {
+    open: boolean;
+    onClose: () => void;
+    /** The base tool definition */
+    tool: ToolDefinition | null;
+    /** The tool instance being configured */
+    instance: AddedToolInstance | null;
+    /** Called when the tool instance is updated */
+    onUpdate: (instanceId: string, updates: Partial<Omit<AddedToolInstance, 'instanceId' | 'toolId'>>) => void;
+    /** Called when the tool instance is removed */
+    onRemove: (instanceId: string) => void;
+    /** Portal container for sub-modals (credential creation) */
+    portalContainer?: HTMLElement | null;
+}
+export declare const ToolConfigPanel: import('react').NamedExoticComponent<ToolConfigPanelProps>;

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

@@ -0,0 +1,5 @@
+interface ValidationPanelProps {
+    className?: string;
+}
+export declare function ValidationPanel({ className }: ValidationPanelProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1 @@
+export * from '../../stores/flow-editor.store';

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

@@ -0,0 +1,6 @@
+export { FlowEditor } from './FlowEditor';
+export type { FlowEditorProps } from './FlowEditor';
+export { FlowWorkbenchView } from './FlowEditor';
+export { NodeSidebar, type SidebarMode, type NodeSidebarProps } from './NodeSidebar';
+export { ActionsSidebar } from './ActionsSidebar';
+export { useFlowEditorStore, useIsLoading } from './flow-editor.store';

package/dist/components/flow-editor/inline-edit.d.ts

@@ -0,0 +1,10 @@
+interface InlineEditProps {
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    className?: string;
+    displayClassName?: string;
+    inputClassName?: string;
+}
+export declare function InlineEdit({ value, onChange, placeholder, className, displayClassName, inputClassName, }: InlineEditProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,26 @@
+import { NodeParamField } from '../../../types/node-definition.types';
+interface ConfigFieldWithTemplateProps {
+    field: NodeParamField;
+    value: unknown;
+    onChange: (value: unknown) => void;
+    templateMode: boolean;
+    onTemplateModeChange: (enabled: boolean) => void;
+    portalContainer?: HTMLElement | null;
+    /** Action / node type id — needed for dynamic option loading. */
+    nodeType?: string;
+    /** All current form values — needed for dynamic option loading. */
+    formValues?: Record<string, unknown>;
+    /** Input data from upstream nodes — used for autocomplete in code fields. */
+    inputData?: Record<string, unknown>;
+    /** Validation error message for this field (from execution errors). */
+    error?: string;
+}
+/**
+ * A config field that supports toggling between static mode (normal form element)
+ * and template mode (Nunjucks template textarea).
+ *
+ * Text-based fields (text, textarea, json, code) are always in template mode.
+ * Other fields (select, number, boolean) show a toggle to switch between modes.
+ */
+export declare const ConfigFieldWithTemplate: ({ field, value, onChange, templateMode, onTemplateModeChange, portalContainer, nodeType, formValues, inputData, error, }: ConfigFieldWithTemplateProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,21 @@
+import { Credential } from '../../../api/types';
+interface Props {
+    credentials: Credential[];
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    isLoading: boolean;
+    isError: boolean;
+    onRetry: () => void;
+    onAddNew: () => void;
+    onEditCredential?: (credential: Credential) => void;
+    onRefreshOAuthCredential?: (credential: Credential) => void;
+    /** ID of the credential currently being refreshed */
+    refreshingCredentialId?: string | null;
+    container?: HTMLElement | null;
+    disablePortal?: boolean;
+    /** Custom label for the add button (default: "Add new credential") */
+    addButtonLabel?: string;
+}
+export declare function CredentialCombobox({ credentials, value, onChange, placeholder, isLoading, isError, onRetry, onAddNew, onEditCredential, onRefreshOAuthCredential, refreshingCredentialId, container, disablePortal, addButtonLabel, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,19 @@
+import { NodeParamField } from '../../../types/node-definition.types';
+import { Credential } from '../../../api/types';
+interface CredentialsSectionProps {
+    fields: NodeParamField[];
+    formValues: Record<string, unknown>;
+    onFieldChange: (fieldName: string, value: string) => void;
+    credentials: Credential[];
+    isLoading: boolean;
+    isError: boolean;
+    onRefresh: () => void;
+    onAddNewCredential: (fieldName: string) => void;
+    onEditCredential?: (credential: Credential) => void;
+    onRefreshOAuthCredential?: (credential: Credential) => void;
+    refreshingCredentialId?: string | null;
+    portalContainer?: HTMLElement | null;
+    disablePortal?: boolean;
+}
+export declare const CredentialsSection: ({ fields, formValues, onFieldChange, credentials, isLoading, isError, onRefresh, onAddNewCredential, onEditCredential, onRefreshOAuthCredential, refreshingCredentialId, portalContainer, disablePortal, }: CredentialsSectionProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,20 @@
+interface DroppableInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    id?: string;
+    multiline?: boolean;
+    rows?: number;
+    fillAvailableHeight?: boolean;
+}
+/**
+ * A text input that accepts drops from the DraggableJsonTree.
+ * When a nunjucks path is dropped, it's inserted at the cursor position.
+ *
+ * For multiline inputs, uses CodeMirror with Nunjucks syntax highlighting.
+ * For single-line inputs, uses a standard Input with drag-drop support.
+ */
+export declare function DroppableInput({ value, onChange, placeholder, disabled, className, id: _id, multiline, rows, fillAvailableHeight, }: DroppableInputProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,22 @@
+import { NodeParamField } from '../../../types/node-definition.types';
+interface DynamicSelectFieldProps {
+    /** The action / node type id (e.g. "core.model"). */
+    actionId: string;
+    /** The field definition — must have `loadOptions`. */
+    field: NodeParamField;
+    /** Current field value. */
+    value: unknown;
+    /** Called when the user picks a new value. */
+    onChange: (value: unknown) => void;
+    /** Current form values — used to extract dependency values. */
+    formValues: Record<string, unknown>;
+    /** Portal container for the dropdown. */
+    portalContainer?: HTMLElement | null;
+}
+/**
+ * A select field whose options are loaded from the server via the
+ * `loadOptions` system.  Re-fetches whenever any of the declared
+ * dependency fields change.
+ */
+export declare function DynamicSelectField({ actionId, field, value, onChange, formValues, portalContainer: _portalContainer, }: DynamicSelectFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,25 @@
+import { UpstreamSlot } from './types';
+interface JsonPreviewPanelProps {
+    title: string;
+    value: string;
+    onChange?: (value: string) => void;
+    error?: string | null;
+    /** Disable JSON syntax error highlighting (useful for output panels showing plain text) */
+    disableLinting?: boolean;
+    /** Show test mode indicator and reset button */
+    isTestMode?: boolean;
+    /** Callback when reset button is clicked */
+    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;
+    /** Icon to display in the toolbar */
+    icon?: React.ReactElement;
+    /** Extra toolbar content (e.g. "Run All" button) */
+    toolbarExtra?: React.ReactNode;
+    /** JSON keys to auto-fold when content is set (e.g. ['previous_nodes']) */
+    defaultFoldKeys?: string[];
+}
+export declare const JsonPreviewPanel: ({ title, value, onChange, error, disableLinting, isTestMode, onReset, upstreamSlots, onRunSlot, icon, toolbarExtra, defaultFoldKeys, }: JsonPreviewPanelProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,14 @@
+import { ToolDefinition } from '../../nodes/ToolSelectorModal';
+interface NodeConfigPanelProps {
+    nodeId: string | null;
+    flowId: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    portalContainer?: HTMLElement | null;
+    /** Available agent tools — only needed for AGENT node type */
+    availableTools?: ToolDefinition[];
+    /** If set, open the Tools tab with this instance pre-selected */
+    initialToolInstanceId?: string | null;
+}
+export declare function NodeConfigPanel({ nodeId, flowId, open, onOpenChange, portalContainer, availableTools, initialToolInstanceId, }: NodeConfigPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,15 @@
+interface NodeConfigPanelHeaderProps {
+    label: string;
+    onLabelChange: (value: string) => void;
+    nodeTypeLabel: string;
+    Icon: React.ComponentType<{
+        className?: string;
+    }>;
+    categoryColor: string;
+    onRunNode?: () => void;
+    runButtonLabel?: string;
+    runDisabled?: boolean;
+    isRunning?: boolean;
+}
+export declare function NodeConfigPanelHeader({ label, onLabelChange, nodeTypeLabel, Icon, categoryColor, onRunNode, runButtonLabel, runDisabled, isRunning, }: NodeConfigPanelHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,16 @@
+import { NodeParamField } from '../../../types/node-definition.types';
+interface ParametersSectionProps {
+    fields: NodeParamField[];
+    formValues: Record<string, unknown>;
+    onFieldChange: (fieldName: string, value: unknown) => void;
+    emptyMessage?: string;
+    portalContainer?: HTMLElement | null;
+    /** Action / node type id — passed through to ConfigFieldWithTemplate for dynamic option loading. */
+    nodeType?: string;
+    /** Input data from upstream nodes — passed through for autocomplete in code fields. */
+    inputData?: Record<string, unknown>;
+    /** Per-field validation errors keyed by field name. */
+    fieldErrors?: Record<string, string>;
+}
+export declare const ParametersSection: ({ fields, formValues, onFieldChange, emptyMessage, portalContainer, nodeType, inputData, fieldErrors, }: ParametersSectionProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,17 @@
+interface SearchableSelectFieldProps {
+    id?: string;
+    value: string;
+    options: {
+        label: string;
+        value: string;
+    }[];
+    placeholder?: string;
+    disabled?: boolean;
+    onChange: (value: string) => void;
+}
+/**
+ * A searchable select field using a combobox pattern (Popover + Command).
+ * Used for select fields with many options (e.g. model lists).
+ */
+export declare function SearchableSelectField({ id, value, options, placeholder, disabled, onChange, }: SearchableSelectFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,18 @@
+interface SwitchCase {
+    slug: string;
+    label: string;
+    expression: string;
+}
+interface SwitchCasesFieldProps {
+    value: unknown;
+    onChange: (value: SwitchCase[]) => void;
+    nodeId: string | null;
+    inputData?: Record<string, unknown>;
+}
+/**
+ * Custom field renderer for the switch node's `cases` parameter.
+ * Renders an ordered list of cases, each with a label, slug, and JS expression.
+ * The default branch is always shown at the bottom and cannot be removed.
+ */
+export declare function SwitchCasesField({ value, onChange, nodeId, inputData }: SwitchCasesFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,2 @@
+export { usePreviewState } from './use-node-config-panel-state';
+export { useNodeExecution } from './use-node-execution';

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

@@ -0,0 +1,24 @@
+import { ReactFlowNodeData } from '@invect/core/types';
+interface UsePreviewStateOptions {
+    nodeId: string | null;
+    updateNodeData: (nodeId: string, data: Partial<ReactFlowNodeData>) => void;
+}
+export declare function usePreviewState({ nodeId, updateNodeData }: UsePreviewStateOptions): {
+    inputPreview: string;
+    outputPreview: string;
+    inputError: string | null;
+    outputError: string | null;
+    isTestMode: boolean;
+    originalInputPreview: string | null;
+    upstreamVariables: string[];
+    setInputPreview: import('react').Dispatch<import('react').SetStateAction<string>>;
+    setOutputPreview: import('react').Dispatch<import('react').SetStateAction<string>>;
+    setInputError: import('react').Dispatch<import('react').SetStateAction<string | null>>;
+    setOutputError: import('react').Dispatch<import('react').SetStateAction<string | null>>;
+    handleInputPreviewChange: (value: string) => void;
+    handleOutputPreviewChange: (value: string) => void;
+    handleResetTestMode: () => void;
+    updateFromExecution: (newInput: string, newOutput: string) => void;
+    refreshInputFromEdges: () => void;
+};
+export {};

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

@@ -0,0 +1,46 @@
+import { UseMutationResult } from '@tanstack/react-query';
+interface SaveOptions {
+    skipSuccessToast?: boolean;
+}
+interface FlowActions {
+    onExecute: () => Promise<void>;
+    isExecuting: boolean;
+    isDirty?: boolean;
+    onSave?: (options?: SaveOptions) => Promise<boolean>;
+    isSaving?: boolean;
+}
+type ExecuteFlowToNodeMutation = UseMutationResult<unknown, Error, {
+    flowId: string;
+    nodeId: string;
+    inputs?: Record<string, unknown>;
+    options?: {
+        useBatchProcessing?: boolean;
+    };
+}>;
+type TestNodeMutation = UseMutationResult<unknown, Error, {
+    nodeType: string;
+    params: Record<string, unknown>;
+    inputs: Record<string, unknown>;
+}>;
+interface UseNodeExecutionOptions {
+    nodeId: string | null;
+    flowId: string;
+    nodeType: string;
+    nodeParams: Record<string, unknown>;
+    executeFlowToNodeMutation: ExecuteFlowToNodeMutation;
+    testNodeMutation?: TestNodeMutation;
+    flowActions: FlowActions | null;
+    updateNodeData: (nodeId: string, data: Record<string, unknown>) => void;
+    isTestMode: boolean;
+    inputPreview: string;
+    onExecutionComplete: (input: string, output: string) => void;
+}
+export declare function useNodeExecution({ nodeId, flowId, nodeType, nodeParams, executeFlowToNodeMutation, testNodeMutation, flowActions, updateNodeData, isTestMode, inputPreview, onExecutionComplete, }: UseNodeExecutionOptions): {
+    isRunning: boolean;
+    runError: string | null;
+    outputError: string | null;
+    fieldErrors: Record<string, string> | null;
+    runNode: () => Promise<void>;
+    setOutputError: import('react').Dispatch<import('react').SetStateAction<string | null>>;
+};
+export {};

package/dist/components/flow-editor/node-config-panel/hooks/use-upstream-slots.d.ts

@@ -0,0 +1,16 @@
+import { UpstreamSlot } from '../types';
+interface UseUpstreamSlotsOptions {
+    nodeId: string | null;
+    flowId: string;
+}
+export declare function useUpstreamSlots({ nodeId, flowId }: UseUpstreamSlotsOptions): {
+    slots: UpstreamSlot[];
+    slotMap: Map<string, UpstreamSlot>;
+    inputPreviewJson: string;
+    runSlot: (slot: UpstreamSlot) => Promise<void>;
+    runAllUnresolved: () => Promise<void>;
+    isAnyLoading: boolean;
+    unresolvedCount: number;
+    upstreamVariables: string[];
+};
+export {};

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

@@ -0,0 +1,18 @@
+import { ToolDefinition, AddedToolInstance } from '../../../nodes/ToolSelectorModal';
+export interface AgentToolsPanelProps {
+    /** Available tools fetched from the API */
+    availableTools: ToolDefinition[];
+    /** Currently added tool instances on this agent */
+    addedTools: AddedToolInstance[];
+    /** Called to add a tool instance */
+    onAddTool: (toolId: string) => string;
+    /** Called to remove a tool instance */
+    onRemoveTool: (instanceId: string) => void;
+    /** Called to update a tool instance */
+    onUpdateTool: (instanceId: string, updates: Partial<Omit<AddedToolInstance, 'instanceId' | 'toolId'>>) => void;
+    /** Portal container for sub-modals */
+    portalContainer?: HTMLElement | null;
+    /** Pre-select a specific tool instance (e.g. opened from AgentToolsBox click) */
+    initialToolInstanceId?: string | null;
+}
+export declare const AgentToolsPanel: import('react').NamedExoticComponent<AgentToolsPanelProps>;