Skip to content

Self-improving AI Employees for everyone

fix(ui): isolate parameter panel state by node

trohitgaee5aceecbdb
diff --git a/client/src/Dashboard.tsx b/client/src/Dashboard.tsx
index 9f6f0432..8cd83ad3 100644
--- a/client/src/Dashboard.tsx
+++ b/client/src/Dashboard.tsx
@@ -677,7 +677,7 @@ const DashboardContent: React.FC = () => {
console.log('[Workflow Run] Execution order:', order);
// Execute the entire workflow via WebSocket
- const workflowResult = await executeWorkflow(nodes, edges);
+ const workflowResult = await executeWorkflow(nodes, edges, undefined, workflowId);
console.log('[Workflow Run] Execution complete:', workflowResult);
@@ -1468,4 +1468,4 @@ const Dashboard: React.FC = () => {
);
};
-export default Dashboard;
\ No newline at end of file
+export default Dashboard;
diff --git a/client/src/ParameterPanel.tsx b/client/src/ParameterPanel.tsx
index a1d8f3a1..0af5f029 100644
--- a/client/src/ParameterPanel.tsx
+++ b/client/src/ParameterPanel.tsx
@@ -7,6 +7,7 @@ import { useWebSocket } from './contexts/WebSocketContext';
import { ExecutionService, ExecutionResult } from './services/executionService';
import { ActionButton } from './components/ui/action-button';
import { NodeIcon } from './assets/icons';
+import { nodeExecutionReducer } from './utils/parameterPanelExecutionState';
const ParameterPanel: React.FC = () => {
const {
@@ -27,9 +28,14 @@ const ParameterPanel: React.FC = () => {
const nodeStatus = selectedNode ? getNodeStatus(selectedNode.id) : null;
const isWaiting = nodeStatus?.status === 'waiting';
- // Execution state
- const [isExecuting, setIsExecuting] = React.useState(false);
- const [executionResults, setExecutionResults] = React.useState<ExecutionResult[]>([]);
+ // Execution state is owned by the physical node. A run may remain in
+ // flight while the user inspects or starts another node, so a panel-wide
+ // boolean/result list would let one node block or overwrite another.
+ const [executionByNode, dispatchExecution] = React.useReducer(nodeExecutionReducer, {});
+
+ const selectedExecution = selectedNode
+ ? executionByNode[selectedNode.id] ?? { running: false, results: [] }
+ : { running: false, results: [] };
const handleModalClose = () => {
@@ -39,15 +45,23 @@ const ParameterPanel: React.FC = () => {
// Execute the current node
const handleRun = async () => {
if (!selectedNode || !nodeDefinition) return;
+
+ // Capture identity before the first await. Selecting another node while
+ // this run is pending must not redirect its result or finally block.
+ const runNode = selectedNode;
+ const runDefinition = nodeDefinition;
+ const runNodeId = runNode.id;
- // Save parameters first if there are unsaved changes
- if (hasUnsavedChanges) {
- await handleSave();
- }
-
- setIsExecuting(true);
-
+ dispatchExecution({ type: 'start', nodeId: runNodeId });
+
try {
+ // Save parameters first if there are unsaved changes. The per-node run
+ // flag is already set so a second click cannot start an overlapping run
+ // while this await is pending.
+ if (hasUnsavedChanges) {
+ await handleSave();
+ }
+
// Get current workflow nodes and edges from app store
const nodes = currentWorkflow?.nodes || [];
@@ -55,8 +69,8 @@ const ParameterPanel: React.FC = () => {
// Execute node via WebSocket
const result: ExecutionResult = await ExecutionService.executeNodeViaWebSocket(
- selectedNode.id,
- nodeDefinition.name,
+ runNodeId,
+ runDefinition.name,
executeNode,
getNodeParameters,
nodes,
@@ -67,10 +81,10 @@ const ParameterPanel: React.FC = () => {
console.log('[ParameterPanel] Execution result:', result);
console.log('[ParameterPanel] Result nodeId:', result.nodeId);
console.log('[ParameterPanel] Result outputs:', result.outputs);
- console.log('[ParameterPanel] Selected node id:', selectedNode.id);
+ console.log('[ParameterPanel] Selected node id:', runNodeId);
// Add result to the beginning of the array (newest first)
- setExecutionResults(prev => [result, ...prev]);
+ dispatchExecution({ type: 'append', nodeId: runNodeId, result });
} catch (error: any) {
console.error('Execution failed:', error);
@@ -78,35 +92,35 @@ const ParameterPanel: React.FC = () => {
// Add error result
const errorResult: ExecutionResult = {
success: false,
- nodeId: selectedNode.id,
- nodeType: nodeDefinition.name,
- nodeName: nodeDefinition.displayName,
+ nodeId: runNodeId,
+ nodeType: runDefinition.name,
+ nodeName: runDefinition.displayName,
timestamp: new Date().toISOString(),
executionTime: 0,
error: error.message || 'Unknown execution error',
nodeData: [[{
json: {
error: error.message || 'Unknown execution error',
- nodeId: selectedNode.id,
+ nodeId: runNodeId,
success: false,
timestamp: new Date().toISOString()
}
}]]
};
- setExecutionResults(prev => [errorResult, ...prev]);
+ dispatchExecution({ type: 'append', nodeId: runNodeId, result: errorResult });
} finally {
- setIsExecuting(false);
+ dispatchExecution({ type: 'finish', nodeId: runNodeId });
}
};
// Clear execution results (both local state and WebSocket nodeStatuses)
const handleClearResults = () => {
- setExecutionResults([]);
+ if (!selectedNode) return;
+ const nodeId = selectedNode.id;
+ dispatchExecution({ type: 'clear', nodeId });
// Also clear the node status from WebSocket context
- if (selectedNode) {
- clearNodeStatus(selectedNode.id);
- }
+ clearNodeStatus(nodeId);
};
@@ -147,13 +161,13 @@ const ParameterPanel: React.FC = () => {
<ActionButton
intent="run"
onClick={handleRun}
- disabled={isExecuting}
- title={isExecuting ? 'Execution in progress...' : 'Execute this node'}
+ disabled={selectedExecution.running}
+ title={selectedExecution.running ? 'Execution in progress...' : 'Execute this node'}
>
<svg width="12" height="12" viewBox="0 0 24 24" fill="currentColor">
<path d="M8 5v14l11-7z" />
</svg>
- {isExecuting ? 'Running...' : 'Run'}
+ {selectedExecution.running ? 'Running...' : 'Run'}
</ActionButton>
)}
<ActionButton intent="tools" onClick={handleSave} disabled={!hasUnsavedChanges}>
@@ -211,7 +225,7 @@ const ParameterPanel: React.FC = () => {
parameters={parameters}
hasUnsavedChanges={hasUnsavedChanges}
onParameterChange={handleParameterChange}
- executionResults={executionResults}
+ executionResults={selectedExecution.results}
onClearResults={handleClearResults}
showInputSection={!hideInputSection}
showOutputSection={!hideOutputSection}
@@ -221,4 +235,4 @@ const ParameterPanel: React.FC = () => {
);
};
-export default ParameterPanel;
\ No newline at end of file
+export default ParameterPanel;
diff --git a/client/src/components/APIKeyValidator.tsx b/client/src/components/APIKeyValidator.tsx
index e4c12306..748fd901 100644
--- a/client/src/components/APIKeyValidator.tsx
+++ b/client/src/components/APIKeyValidator.tsx
@@ -9,6 +9,7 @@ import { useApiKeyValidation } from '../hooks/useApiKeyValidation';
import { cn } from '@/lib/utils';
interface APIKeyValidatorProps {
+ requestKey?: string;
value: string;
onChange: (value: string) => void;
placeholder?: string;
@@ -24,6 +25,7 @@ interface APIKeyValidatorProps {
}
const APIKeyValidator: React.FC<APIKeyValidatorProps> = ({
+ requestKey,
value,
onChange,
placeholder,
@@ -36,21 +38,26 @@ const APIKeyValidator: React.FC<APIKeyValidatorProps> = ({
}) => {
const { status, hasStoredKey, validate, clear, getStoredKey, isValidating, isValid } = useApiKeyValidation({
provider: validationConfig.provider,
+ requestKey,
onSuccess: onValidationSuccess
});
useEffect(() => {
+ let cancelled = false;
if (hasStoredKey && !value) {
getStoredKey().then((storedKey) => {
- if (storedKey) onChange(storedKey);
+ if (!cancelled && storedKey) onChange(storedKey);
});
}
- }, [hasStoredKey, value, onChange, getStoredKey]);
+ return () => {
+ cancelled = true;
+ };
+ }, [hasStoredKey, value, onChange, getStoredKey, requestKey]);
const handleValidate = () => validate(value);
const handleClear = async () => {
- await clear();
- onChange('');
+ const cleared = await clear();
+ if (cleared) onChange('');
};
return (
diff --git a/client/src/components/ParameterRenderer.tsx b/client/src/components/ParameterRenderer.tsx
index 5b09a670..38956e04 100644
--- a/client/src/components/ParameterRenderer.tsx
+++ b/client/src/components/ParameterRenderer.tsx
@@ -160,6 +160,7 @@ const CollectionRenderer: React.FC<{
// Group ID Selector - with Load Groups button and dropdown
const GroupIdSelector: React.FC<{
+ requestKey: string;
value: string;
onChange: (value: string) => void;
onNameChange?: (name: string) => void;
@@ -169,7 +170,7 @@ const GroupIdSelector: React.FC<{
onDragOver: (e: React.DragEvent) => void;
onDragLeave: (e: React.DragEvent) => void;
onDrop: (e: React.DragEvent) => void;
-}> = ({ value, onChange, onNameChange, storedName, placeholder, isDragOver, onDragOver, onDragLeave, onDrop }) => {
+}> = ({ requestKey, value, onChange, onNameChange, storedName, placeholder, isDragOver, onDragOver, onDragLeave, onDrop }) => {
const [groups, setGroups] = useState<Array<{ jid: string; name: string; topic?: string; size?: number; is_community?: boolean }>>([]);
const [isLoading, setIsLoading] = useState(false);
const [showDropdown, setShowDropdown] = useState(false);
@@ -178,6 +179,21 @@ const GroupIdSelector: React.FC<{
const [localGroupName, setLocalGroupName] = useState<string | null>(null);
const selectedGroupName = storedName || localGroupName;
const { getWhatsAppGroups } = useWebSocket();
+ const requestGeneration = React.useRef(0);
+ const activeRequestKey = React.useRef(requestKey);
+ activeRequestKey.current = requestKey;
+
+ useEffect(() => {
+ requestGeneration.current += 1;
+ setGroups([]);
+ setLocalGroupName(null);
+ setShowDropdown(false);
+ setError(null);
+ setIsLoading(false);
+ return () => {
+ requestGeneration.current += 1;
+ };
+ }, [requestKey]);
// Sync local state with stored name
useEffect(() => {
@@ -187,10 +203,17 @@ const GroupIdSelector: React.FC<{
}, [storedName]);
const handleLoadGroups = async () => {
+ const request = ++requestGeneration.current;
+ const requestKeyAtStart = requestKey;
+ const isCurrent = () => (
+ request === requestGeneration.current
+ && activeRequestKey.current === requestKeyAtStart
+ );
setIsLoading(true);
setError(null);
try {
const result = await getWhatsAppGroups();
+ if (!isCurrent()) return;
console.log('[GroupIdSelector] Raw groups from API:', result.groups?.map(g => ({ name: g.name, jid: g.jid, is_community: g.is_community })));
if (result.success && result.groups.length > 0) {
// Filter out communities - they don't have regular chat history
@@ -216,9 +239,13 @@ const GroupIdSelector: React.FC<{
setError('No groups found');
}
} catch (err: any) {
- setError(err.message || 'Failed to load groups');
+ if (isCurrent()) {
+ setError(err.message || 'Failed to load groups');
+ }
} finally {
- setIsLoading(false);
+ if (isCurrent()) {
+ setIsLoading(false);
+ }
}
};
@@ -305,6 +332,7 @@ const GroupIdSelector: React.FC<{
// Sender Number Selector - with Load Members button and dropdown (loads from selected group)
const SenderNumberSelector: React.FC<{
+ requestKey: string;
value: string;
onChange: (value: string) => void;
onNameChange?: (name: string) => void;
@@ -315,7 +343,7 @@ const SenderNumberSelector: React.FC<{
onDragLeave: (e: React.DragEvent) => void;
onDrop: (e: React.DragEvent) => void;
groupId: string; // The selected group to load members from
-}> = ({ value, onChange, onNameChange, storedName, placeholder, isDragOver, onDragOver, onDragLeave, onDrop, groupId }) => {
+}> = ({ requestKey, value, onChange, onNameChange, storedName, placeholder, isDragOver, onDragOver, onDragLeave, onDrop, groupId }) => {
const [members, setMembers] = useState<Array<{ phone: string; name: string; jid: string; is_admin?: boolean }>>([]);
const [isLoading, setIsLoading] = useState(false);
const [showDropdown, setShowDropdown] = useState(false);
@@ -324,6 +352,22 @@ const SenderNumberSelector: React.FC<{
const [localMemberName, setLocalMemberName] = useState<string | null>(null);
const selectedMemberName = storedName || localMemberName;
const { getWhatsAppGroupInfo } = useWebSocket();
+ const requestGeneration = React.useRef(0);
+ const selectorIdentity = `${requestKey}\u0000${groupId}`;
+ const activeSelectorIdentity = React.useRef(selectorIdentity);
+ activeSelectorIdentity.current = selectorIdentity;
+
+ useEffect(() => {
+ requestGeneration.current += 1;
+ setMembers([]);
+ setLocalMemberName(null);
+ setShowDropdown(false);
+ setError(null);
+ setIsLoading(false);
+ return () => {
+ requestGeneration.current += 1;
+ };
+ }, [requestKey, groupId]);
// Sync local state with stored name
useEffect(() => {
@@ -338,10 +382,17 @@ const SenderNumberSelector: React.FC<{
return;
}
+ const request = ++requestGeneration.current;
+ const identityAtStart = selectorIdentity;
+ const isCurrent = () => (
+ request === requestGeneration.current
+ && activeSelectorIdentity.current === identityAtStart
+ );
setIsLoading(true);
setError(null);
try {
const result = await getWhatsAppGroupInfo(groupId);
+ if (!isCurrent()) return;
if (result.success && result.participants && result.participants.length > 0) {
setMembers(result.participants);
setShowDropdown(true);
@@ -362,9 +413,13 @@ const SenderNumberSelector: React.FC<{
setError('No members found');
}
} catch (err: any) {
- setError(err.message || 'Failed to load members');
+ if (isCurrent()) {
+ setError(err.message || 'Failed to load members');
+ }
} finally {
- setIsLoading(false);
+ if (isCurrent()) {
+ setIsLoading(false);
+ }
}
};
@@ -471,6 +526,7 @@ const SenderNumberSelector: React.FC<{
// Channel JID Selector - with Load Channels button and dropdown
const ChannelJidSelector: React.FC<{
+ requestKey: string;
value: string;
onChange: (value: string) => void;
onNameChange?: (name: string) => void;
@@ -480,7 +536,7 @@ const ChannelJidSelector: React.FC<{
onDragOver: (e: React.DragEvent) => void;
onDragLeave: (e: React.DragEvent) => void;
onDrop: (e: React.DragEvent) => void;
-}> = ({ value, onChange, onNameChange, storedName, placeholder, isDragOver, onDragOver, onDragLeave, onDrop }) => {
+}> = ({ requestKey, value, onChange, onNameChange, storedName, placeholder, isDragOver, onDragOver, onDragLeave, onDrop }) => {
const [channels, setChannels] = useState<Array<{ jid: string; name: string; subscriber_count?: number; role?: string }>>([]);
const [isLoading, setIsLoading] = useState(false);
const [showDropdown, setShowDropdown] = useState(false);
@@ -488,16 +544,38 @@ const ChannelJidSelector: React.FC<{
const [localChannelName, setLocalChannelName] = useState<string | null>(null);
const selectedChannelName = storedName || localChannelName;
const { getWhatsAppChannels } = useWebSocket();
+ const requestGeneration = React.useRef(0);
+ const activeRequestKey = React.useRef(requestKey);
+ activeRequestKey.current = requestKey;
+
+ useEffect(() => {
+ requestGeneration.current += 1;
+ setChannels([]);
+ setLocalChannelName(null);
+ setShowDropdown(false);
+ setError(null);
+ setIsLoading(false);
+ return () => {
+ requestGeneration.current += 1;
+ };
+ }, [requestKey]);
useEffect(() => {
if (storedName) setLocalChannelName(storedName);
}, [storedName]);
const handleLoadChannels = async () => {
+ const request = ++requestGeneration.current;
+ const requestKeyAtStart = requestKey;
+ const isCurrent = () => (
+ request === requestGeneration.current
+ && activeRequestKey.current === requestKeyAtStart
+ );
setIsLoading(true);
setError(null);
try {
const result = await getWhatsAppChannels();
+ if (!isCurrent()) return;
if (result.success && result.channels.length > 0) {
setChannels(result.channels);
setShowDropdown(true);
@@ -514,9 +592,13 @@ const ChannelJidSelector: React.FC<{
setError('No channels found');
}
} catch (err: any) {
- setError(err.message || 'Failed to load channels');
+ if (isCurrent()) {
+ setError(err.message || 'Failed to load channels');
+ }
} finally {
- setIsLoading(false);
+ if (isCurrent()) {
+ setIsLoading(false);
+ }
}
};
@@ -689,6 +771,10 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
const selectedNode = useAppStore((s) => s.selectedNode);
const { getNodeParameters, sendRequest } = useWebSocket();
const { getStoredApiKey, hasStoredKey, getStoredModels, getProviderDefaults } = useApiKeys();
+ const activeNodeIdRef = React.useRef<string | null>(selectedNode?.id ?? null);
+ activeNodeIdRef.current = selectedNode?.id ?? null;
+ const onChangeRef = React.useRef(onChange);
+ onChangeRef.current = onChange;
// Don't render hidden parameters
if (parameter.type === 'hidden') {
@@ -697,13 +783,29 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
// Load node parameters for expression resolution
useEffect(() => {
+ const nodeId = selectedNode?.id;
+ let cancelled = false;
+
+ if (!nodeId) {
+ setNodeParameters({});
+ return () => {
+ cancelled = true;
+ };
+ }
+
+ // Never render a previous node's derived parameter snapshot while the
+ // request for the newly selected node is pending.
+ setNodeParameters({});
const loadParameters = async () => {
- if (selectedNode?.id) {
- const result = await getNodeParameters(selectedNode.id);
- if (result?.parameters) setNodeParameters(result.parameters);
+ const result = await getNodeParameters(nodeId);
+ if (!cancelled && activeNodeIdRef.current === nodeId && result?.parameters) {
+ setNodeParameters(result.parameters);
}
};
- loadParameters();
+ void loadParameters();
+ return () => {
+ cancelled = true;
+ };
}, [selectedNode?.id, getNodeParameters]);
// Auto-load stored API key and models when provider changes
@@ -716,9 +818,15 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
useEffect(() => {
hasAutoSelectedRef.current = false;
prevProviderRef.current = null;
+ setDynamicOptions([]);
}, [selectedNode?.id]);
useEffect(() => {
+ const nodeId = selectedNode?.id;
+ const selectedNodeType = selectedNode?.type || selectedNode?.data?.nodeType;
+ let cancelled = false;
+ const isCurrent = () => !cancelled && !!nodeId && activeNodeIdRef.current === nodeId;
+
const loadStoredKeyForProvider = async () => {
// Only run for api_key or model parameters. Schema-canonical
// name from the chat-model `_base.py` Pydantic model is
@@ -730,13 +838,12 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
// Get provider from allParameters or derive from node type
let provider = allParameters?.provider;
- if (!provider && selectedNode) {
- const nodeType = selectedNode.type || selectedNode.data?.nodeType;
- if (nodeType) {
- provider = NODE_TYPE_TO_PROVIDER[nodeType];
+ if (!provider && selectedNodeType) {
+ if (selectedNodeType) {
+ provider = NODE_TYPE_TO_PROVIDER[selectedNodeType];
}
}
- if (!provider) return;
+ if (!provider || !nodeId || !isCurrent()) return;
// Distinguish between initial load (prevProvider was null) and actual user-initiated provider change
// On initial load: respect saved model if it exists
@@ -754,27 +861,32 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
try {
const hasKey = await hasStoredKey(provider);
+ if (!isCurrent()) return;
if (hasKey) {
// Auto-load API key for api_key parameter - always update when provider changes
if (parameter.name === 'api_key' && isActualProviderChange) {
const storedKey = await getStoredApiKey(provider);
+ if (!isCurrent()) return;
if (storedKey) {
- onChange(storedKey);
+ onChangeRef.current(storedKey);
}
}
// Auto-load models for model parameter
- if (shouldAutoSelectModel && selectedNode) {
+ if (shouldAutoSelectModel) {
const models = await getStoredModels(provider);
+ if (!isCurrent()) return;
if (models?.length) {
const modelOptions = DynamicParameterService.createModelOptions(models);
- DynamicParameterService.updateParameterOptions(selectedNode.id, 'model', modelOptions);
// Get the configured default model for this provider
const providerDefaults = await getProviderDefaults(provider);
+ if (!isCurrent()) return;
const configuredDefaultModel = providerDefaults?.default_model || '';
+ DynamicParameterService.updateParameterOptions(nodeId, 'model', modelOptions);
+
// Extract model ID (handles both string and object formats)
const getModelId = (model: any) => typeof model === 'string' ? model : model.id;
@@ -790,12 +902,12 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
// When user actively changes provider, reset to default model
// to prevent mismatched provider/model combinations (e.g., OpenAI model with Anthropic provider)
if (isActualProviderChange) {
- onChange(defaultModelToUse);
+ onChangeRef.current(defaultModelToUse);
} else {
// Initial load or no provider change - only auto-select if no saved model exists
const savedModel = value || allParameters?.model;
if (!savedModel || savedModel === '') {
- onChange(defaultModelToUse);
+ onChangeRef.current(defaultModelToUse);
}
// If saved model exists, keep it (don't call onChange)
}
@@ -803,22 +915,28 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
}
}
} else {
+ if (!isCurrent()) return;
// No stored key for this provider - clear the fields
if (parameter.name === 'api_key') {
- onChange('');
+ onChangeRef.current('');
}
if (parameter.name === 'model') {
- onChange('');
+ onChangeRef.current('');
hasAutoSelectedRef.current = true;
}
}
} catch (error) {
- console.warn('Error loading stored key info:', error);
+ if (isCurrent()) {
+ console.warn('Error loading stored key info:', error);
+ }
}
};
- loadStoredKeyForProvider();
- }, [allParameters?.provider, parameter.name, hasStoredKey, getStoredApiKey, getStoredModels, getProviderDefaults, selectedNode?.id, selectedNode?.type, onChange, isLoadingParameters, value, allParameters?.model]);
+ void loadStoredKeyForProvider();
+ return () => {
+ cancelled = true;
+ };
+ }, [allParameters?.provider, parameter.name, hasStoredKey, getStoredApiKey, getStoredModels, getProviderDefaults, selectedNode?.id, selectedNode?.type, isLoadingParameters, value, allParameters?.model]);
// Merge database params with current form params (current takes precedence)
const resolvedParameters = { ...nodeParameters, ...allParameters };
@@ -830,10 +948,16 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
// Load dynamic options based on loadOptionsMethod
useEffect(() => {
+ const nodeId = selectedNode?.id;
+ const nodeType = selectedNode?.data?.nodeType || selectedNode?.type;
+ const method = isINodeProperties(parameter) ? parameter.typeOptions?.loadOptionsMethod : undefined;
+ let cancelled = false;
+ const isCurrent = () => !cancelled && !!nodeId && activeNodeIdRef.current === nodeId;
+
const loadDynamicOptions = async () => {
- if (!selectedNode || !isINodeProperties(parameter) || !parameter.typeOptions?.loadOptionsMethod) return;
+ if (!nodeId || !nodeType || !isINodeProperties(parameter) || !method) return;
- const dependsOn = parameter.typeOptions.loadOptionsDependsOn || [];
+ const dependsOn = parameter.typeOptions?.loadOptionsDependsOn || [];
const allParamsResolved = { ...nodeParameters, ...allParameters };
// Check if all dependencies are satisfied
@@ -842,11 +966,9 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
try {
// Get the node definition to access methods
- const nodeType = selectedNode.data?.nodeType || selectedNode.type;
const nodeDef = nodeType ? resolveNodeDescription(nodeType) : null;
let rawOptions: Array<{ value: any; name?: string; label?: string }> = [];
- const method = parameter.typeOptions.loadOptionsMethod;
if (nodeDef?.methods?.loadOptions?.[method]) {
// Legacy frontend-defined loader (rare — most nodes are slimmed).
@@ -867,18 +989,23 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
{
method,
params: {
- node_id: selectedNode.id,
+ node_id: nodeId,
node_type: nodeType,
...allParamsResolved,
},
},
);
+ if (!isCurrent()) return;
rawOptions = res?.options ?? [];
} catch (err) {
- console.error(`[ParameterRenderer] backend load_options(${method}) failed:`, err);
+ if (isCurrent()) {
+ console.error(`[ParameterRenderer] backend load_options(${method}) failed:`, err);
+ }
}
}
+ if (!isCurrent()) return;
+
// Backend returns `{value, label}`; INodePropertyOption wants
// `{name, value}`. Normalise while preserving the original label.
const options = rawOptions.map(o => ({
@@ -887,34 +1014,42 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
}));
setDynamicOptions(options);
- DynamicParameterService.updateParameterOptions(selectedNode.id, parameter.name, options);
+ DynamicParameterService.updateParameterOptions(nodeId, parameter.name, options);
if (options.length > 0 && (!currentValue || currentValue === '')) {
- onChange(options[0].value);
+ onChangeRef.current(options[0].value);
}
} catch (error) {
- console.error('Error loading dynamic options:', error);
+ if (isCurrent()) {
+ console.error('Error loading dynamic options:', error);
+ }
}
};
- loadDynamicOptions();
+ void loadDynamicOptions();
+ return () => {
+ cancelled = true;
+ };
}, [selectedNode?.id, isINodeProperties(parameter) && parameter.typeOptions?.loadOptionsMethod, nodeParameters, allParameters, parameter.name]);
// Load default parameters for Android service nodes when service_id or action changes
useEffect(() => {
+ const nodeId = selectedNode?.id;
+ const nodeType = selectedNode?.data?.nodeType || selectedNode?.type;
+ const allParamsResolved = { ...nodeParameters, ...allParameters };
+ const serviceId = allParamsResolved.service_id;
+ const action = allParamsResolved.action;
+ const abortController = new AbortController();
+ let cancelled = false;
+ const isCurrent = () => !cancelled && !!nodeId && activeNodeIdRef.current === nodeId;
+
const loadDefaultParameters = async () => {
- if (!selectedNode || parameter.name !== 'parameters') return;
+ if (!nodeId || !nodeType || parameter.name !== 'parameters') return;
- const nodeType = selectedNode.data?.nodeType || selectedNode.type;
// Wave 10.E: backend group membership with bundled-definition fallback
const isAndroid = isNodeInBackendGroup(nodeType, 'android')
?? (resolveNodeDescription(nodeType)?.group ?? []).includes('android');
if (!isAndroid) return;
- // Merge database params with current form params (current takes precedence)
- const allParamsResolved = { ...nodeParameters, ...allParameters };
- const serviceId = allParamsResolved.service_id;
- const action = allParamsResolved.action;
-
if (!serviceId || !action) {
console.log('[AndroidService] Skipping - missing serviceId or action:', { serviceId, action });
return;
@@ -923,22 +1058,30 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
try {
console.log('[AndroidService] Fetching default parameters for:', { serviceId, action });
const response = await fetch(`${API_CONFIG.PYTHON_BASE_URL}/api/android/services/${serviceId}/actions/${action}/parameters`, {
- credentials: 'include'
+ credentials: 'include',
+ signal: abortController.signal,
});
const data = await response.json();
+ if (!isCurrent()) return;
console.log('[AndroidService] Default parameters response:', data);
if (data.success && data.default_parameters) {
// Always update with new defaults when service/action changes
console.log('[AndroidService] Setting parameters to:', data.default_parameters);
- onChange(data.default_parameters);
+ onChangeRef.current(data.default_parameters);
}
} catch (error) {
- console.error('[AndroidService] Error loading default parameters:', error);
+ if (isCurrent() && (error as Error)?.name !== 'AbortError') {
+ console.error('[AndroidService] Error loading default parameters:', error);
+ }
}
};
- loadDefaultParameters();
+ void loadDefaultParameters();
+ return () => {
+ cancelled = true;
+ abortController.abort();
+ };
}, [
selectedNode?.id,
parameter.name,
@@ -950,18 +1093,19 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
// Subscribe to dynamic parameter updates
useEffect(() => {
- if (!selectedNode) return;
+ const nodeId = selectedNode?.id;
+ if (!nodeId) return;
- const unsubscribe = DynamicParameterService.subscribe((nodeId, parameterName, options) => {
+ const unsubscribe = DynamicParameterService.subscribe((updatedNodeId, parameterName, options) => {
- if (nodeId === selectedNode.id && parameterName === parameter.name) {
+ if (updatedNodeId === nodeId && activeNodeIdRef.current === nodeId && parameterName === parameter.name) {
setDynamicOptions(options);
}
});
// Check for existing dynamic options
- const existingOptions = DynamicParameterService.getParameterOptions(selectedNode.id, parameter.name);
+ const existingOptions = DynamicParameterService.getParameterOptions(nodeId, parameter.name);
if (existingOptions) {
setDynamicOptions(existingOptions);
@@ -972,20 +1116,20 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
// Handle API key validation success
const handleApiKeyValidationSuccess = (models: string[]) => {
-
- if (!selectedNode) {
- console.warn('ParameterRenderer: No selected node for dynamic options update');
+ const nodeId = selectedNode?.id;
+ if (!nodeId || activeNodeIdRef.current !== nodeId) {
+ console.warn('ParameterRenderer: Ignoring validation result for an inactive node');
return;
}
// Always update the 'model' parameter with dynamic options when API key validation succeeds
// This callback can be triggered from any parameter (usually the apiKey parameter)
const modelOptions = DynamicParameterService.createModelOptions(models);
- DynamicParameterService.updateParameterOptions(selectedNode.id, 'model', modelOptions);
+ DynamicParameterService.updateParameterOptions(nodeId, 'model', modelOptions);
// If this callback is triggered from the model parameter itself and it's empty, auto-select first model
if (parameter.name === 'model' && !currentValue && models.length > 0) {
- onChange(models[0]);
+ onChangeRef.current(models[0]);
}
};
@@ -1144,6 +1288,7 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
return (
<APIKeyValidator
+ requestKey={`${selectedNode?.id ?? 'unselected'}:${String(resolvedProvider ?? '')}`}
value={currentValue || ''}
onChange={onChange}
placeholder={parameter.placeholder}
@@ -1232,6 +1377,7 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
const storedGroupName = allParameters?.group_name || '';
return (
<GroupIdSelector
+ requestKey={selectedNode?.id ?? 'unselected'}
value={currentValue || ''}
onChange={onChange}
onNameChange={(name) => onParameterChange?.('group_name', name)}
@@ -1249,6 +1395,7 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
const storedChannelName = allParameters?.channel_display_name || '';
return (
<ChannelJidSelector
+ requestKey={selectedNode?.id ?? 'unselected'}
value={currentValue || ''}
onChange={onChange}
onNameChange={(name) => onParameterChange?.('channel_display_name', name)}
@@ -1267,6 +1414,7 @@ const ParameterRenderer: React.FC<ParameterRendererProps> = ({
const storedSenderName = allParameters?.sender_name || '';
return (
<SenderNumberSelector
+ requestKey={selectedNode?.id ?? 'unselected'}
value={currentValue || ''}
onChange={onChange}
onNameChange={(name) => onParameterChange?.('sender_name', name)}
diff --git a/client/src/components/parameterPanel/InputSection.tsx b/client/src/components/parameterPanel/InputSection.tsx
index 6610b4da..e4a42bf5 100644
--- a/client/src/components/parameterPanel/InputSection.tsx
+++ b/client/src/components/parameterPanel/InputSection.tsx
@@ -1,4 +1,4 @@
-import React, { useState, useEffect } from 'react';
+import React, { useState, useEffect, useRef } from 'react';
import {
Database,
Link as LinkIcon,
@@ -158,19 +158,35 @@ const InputSection: React.FC<InputSectionProps> = ({ nodeId, visible = true }) =
const currentWorkflow = useAppStore((s) => s.currentWorkflow);
const { getNodeOutput, sendRequest } = useWebSocket();
const [expandedNodes, setExpandedNodes] = useState<Set<string>>(new Set());
- const [connectedNodes, setConnectedNodes] = useState<NodeData[]>([]);
- const [loading, setLoading] = useState(false);
+ const requestKey = `${currentWorkflow?.id ?? ''}:${nodeId}`;
+ const [connectedState, setConnectedState] = useState<{
+ key: string;
+ nodes: NodeData[];
+ loading: boolean;
+ }>({ key: '', nodes: [], loading: false });
+ const activeRequestKey = useRef(requestKey);
+ activeRequestKey.current = requestKey;
+ const connectedNodes = connectedState.key === requestKey ? connectedState.nodes : [];
+ const loading = connectedState.key !== requestKey || connectedState.loading;
const { handleVariableDragStart, getTemplateVariableName } = useDragVariable(nodeId);
// Fetch connected node data with execution results from backend
useEffect(() => {
+ const fetchKey = requestKey;
+ let cancelled = false;
+ const isCurrent = () => !cancelled && activeRequestKey.current === fetchKey;
+
const fetchConnectedNodes = async () => {
if (!currentWorkflow || !nodeId) {
- setConnectedNodes([]);
+ if (isCurrent()) {
+ setConnectedState({ key: fetchKey, nodes: [], loading: false });
+ setExpandedNodes(new Set());
+ }
return;
}
- setLoading(true);
+ setConnectedState({ key: fetchKey, nodes: [], loading: true });
+ setExpandedNodes(new Set());
const nodes = currentWorkflow.nodes || [];
const edges = currentWorkflow.edges || [];
@@ -327,14 +343,17 @@ const InputSection: React.FC<InputSectionProps> = ({ nodeId, visible = true }) =
});
const nodeDataResults = await Promise.all(nodeDataPromises);
- setConnectedNodes(nodeDataResults);
+ if (!isCurrent()) return;
+ setConnectedState({ key: fetchKey, nodes: nodeDataResults, loading: false });
setExpandedNodes(new Set(nodeDataResults.map(n => n.id)));
- setLoading(false);
};
- fetchConnectedNodes();
+ void fetchConnectedNodes();
+ return () => {
+ cancelled = true;
+ };
// eslint-disable-next-line react-hooks/exhaustive-deps -- sendRequest is a stable WS-context callback; including it would re-fetch on every reconnect.
- }, [nodeId, currentWorkflow, getNodeOutput]);
+ }, [nodeId, currentWorkflow, getNodeOutput, requestKey]);
const toggleNode = (id: string) => {
setExpandedNodes(prev => {
diff --git a/client/src/components/parameterPanel/MiddleSection.tsx b/client/src/components/parameterPanel/MiddleSection.tsx
index a55f5e87..5fcd1777 100644
--- a/client/src/components/parameterPanel/MiddleSection.tsx
+++ b/client/src/components/parameterPanel/MiddleSection.tsx
@@ -41,6 +41,7 @@ import { NodeIcon } from '../../assets/icons';
import { ExecutionResult } from '../../services/executionService';
import { Edge } from 'reactflow';
import { shouldShowParameter } from '../../utils/parameterVisibility';
+import { latestResultForNode } from '../../utils/executionResults';
import { resolveNodeDescription, getCachedNodeSpec } from '../../lib/nodeSpec';
@@ -491,7 +492,10 @@ const MiddleSection: React.FC<MiddleSectionProps> = ({
const getConsoleOutput = (): string => {
if (executionResults.length === 0) return '';
- const latestResult = executionResults[0];
+ // Results are newest-first, but the panel can retain entries for nodes
+ // whose executions completed while another node was selected.
+ const latestResult = latestResultForNode(executionResults, nodeId);
+ if (!latestResult) return '';
const outputs = latestResult.outputs || latestResult.data || latestResult.nodeData?.[0]?.[0]?.json;
if (!outputs) return '';
diff --git a/client/src/contexts/WebSocketContext.tsx b/client/src/contexts/WebSocketContext.tsx
index fb961681..315ec70d 100644
--- a/client/src/contexts/WebSocketContext.tsx
+++ b/client/src/contexts/WebSocketContext.tsx
@@ -23,6 +23,7 @@ import { nodeParamsQueryKey } from '../hooks/useNodeParamsQuery';
import { WORKFLOWS_QUERY_KEY } from '../hooks/useWorkflowsQuery';
import type { WorkflowEvent } from '../types/cloudEvents';
import { WS_CLOSE, WS_RECONNECT } from '../lib/connectionConfig';
+import { todoQueryKeyFromEvent } from '../lib/todoQuery';
import {
useNodeStatusStore,
useNodeStatusForId,
@@ -337,7 +338,7 @@ interface WebSocketContextValue {
// Node Execution
executeNode: (nodeId: string, nodeType: string, parameters: Record<string, any>, nodes?: any[], edges?: any[]) => Promise<any>;
- executeWorkflow: (nodes: any[], edges: any[], sessionId?: string) => Promise<any>;
+ executeWorkflow: (nodes: any[], edges: any[], sessionId?: string, workflowId?: string) => Promise<any>;
getNodeOutput: (nodeId: string, outputName?: string) => Promise<any>;
// Trigger/Event Waiting
@@ -761,12 +762,18 @@ export const WebSocketProvider: React.FC<{ children: React.ReactNode }> = ({ chi
// server/nodes/tool/write_todos/_events.py, emitted via the
// centralized dispatcher on both the write_todos tool run AND
// manual edits from the Current Todos panel (set_todos). Refresh
- // the open panel's ['todos', session_key] query so it reflects the
- // new list live, across clients, without polling.
- const event = data as WorkflowEvent<{ session_key?: string; todos?: unknown[] }>;
- const sessionKey = event?.data?.session_key || event?.subject;
- if (sessionKey) {
- queryClient.setQueryData(['todos', sessionKey], event?.data?.todos ?? []);
+ // the exact workflow + node query so sibling writeTodos panels do
+ // not overwrite one another. Missing-node legacy events retain the
+ // historical session-key route.
+ const event = data as WorkflowEvent<{
+ session_key?: string;
+ workflow_id?: string | null;
+ node_id?: string | null;
+ todos?: unknown[];
+ }>;
+ const queryKey = todoQueryKeyFromEvent(event?.data, event?.subject);
+ if (queryKey) {
+ queryClient.setQueryData(queryKey, event?.data?.todos ?? []);
}
break;
}
@@ -2154,7 +2161,8 @@ export const WebSocketProvider: React.FC<{ children: React.ReactNode }> = ({ chi
const executeWorkflowAsync = useCallback(async (
nodes: any[],
edges: any[],
- sessionId?: string
+ sessionId?: string,
+ workflowId?: string,
): Promise<any> => {
try {
const response = await sendRequest<any>('execute_workflow', {
@@ -2170,7 +2178,8 @@ export const WebSocketProvider: React.FC<{ children: React.ReactNode }> = ({ chi
sourceHandle: edge.sourceHandle || undefined,
targetHandle: edge.targetHandle || undefined
})),
- session_id: sessionId || 'default'
+ session_id: sessionId || 'default',
+ workflow_id: workflowId,
});
return response;
diff --git a/client/src/hooks/useApiKeyValidation.ts b/client/src/hooks/useApiKeyValidation.ts
index 4fcef1f1..b2c5e6bf 100644
--- a/client/src/hooks/useApiKeyValidation.ts
+++ b/client/src/hooks/useApiKeyValidation.ts
@@ -1,4 +1,4 @@
-import { useState, useEffect, useCallback } from 'react';
+import { useState, useEffect, useCallback, useRef } from 'react';
import { toast } from 'sonner';
import { useApiKeys } from './useApiKeys';
@@ -6,12 +6,22 @@ export type ValidationStatus = 'idle' | 'validating' | 'valid' | 'invalid';
interface UseApiKeyValidationProps {
provider?: string;
+ requestKey?: string;
onSuccess?: (models: string[]) => void;
}
-export const useApiKeyValidation = ({ provider, onSuccess }: UseApiKeyValidationProps) => {
+export const useApiKeyValidation = ({ provider, requestKey, onSuccess }: UseApiKeyValidationProps) => {
const [status, setStatus] = useState<ValidationStatus>('idle');
const [hasStoredKeyState, setHasStoredKeyState] = useState(false);
+ const requestGeneration = useRef(0);
+ const requestIdentity = `${requestKey ?? ''}\u0000${provider ?? ''}`;
+ const activeRequestIdentity = useRef(requestIdentity);
+ // Refs update during render, before effect cleanup. This closes the small
+ // window where node A's promise can settle after node B has rendered but
+ // before A's effect cleanup increments the generation counter.
+ activeRequestIdentity.current = requestIdentity;
+ const onSuccessRef = useRef(onSuccess);
+ onSuccessRef.current = onSuccess;
// Use WebSocket-based API key management
const {
@@ -24,28 +34,45 @@ export const useApiKeyValidation = ({ provider, onSuccess }: UseApiKeyValidation
// Check for existing key on mount
useEffect(() => {
- if (!provider) return;
+ const request = ++requestGeneration.current;
+ const identity = requestIdentity;
+ const isCurrent = () => (
+ request === requestGeneration.current
+ && activeRequestIdentity.current === identity
+ );
+ setStatus('idle');
+ setHasStoredKeyState(false);
+ if (!provider) return () => {
+ requestGeneration.current += 1;
+ };
const checkStoredKey = async () => {
try {
const hasKey = await wsHasStoredKey(provider);
+ if (!isCurrent()) return;
if (hasKey) {
setHasStoredKeyState(true);
setStatus('valid');
// Try to get models if there's a stored key
const models = await wsGetStoredModels(provider);
- if (models?.length && onSuccess) {
- onSuccess(models);
+ if (!isCurrent()) return;
+ if (models?.length && onSuccessRef.current) {
+ onSuccessRef.current(models);
}
}
} catch (error) {
- console.warn('Error checking stored key:', error);
+ if (isCurrent()) {
+ console.warn('Error checking stored key:', error);
+ }
}
};
- checkStoredKey();
- }, [provider, onSuccess, wsHasStoredKey, wsGetStoredModels]);
+ void checkStoredKey();
+ return () => {
+ requestGeneration.current += 1;
+ };
+ }, [provider, requestKey, requestIdentity, wsHasStoredKey, wsGetStoredModels]);
const validate = useCallback(async (apiKey: string) => {
if (!provider || !apiKey.trim()) {
@@ -53,46 +80,68 @@ export const useApiKeyValidation = ({ provider, onSuccess }: UseApiKeyValidation
return;
}
+ const request = ++requestGeneration.current;
+ const identity = requestIdentity;
+ const isCurrent = () => (
+ request === requestGeneration.current
+ && activeRequestIdentity.current === identity
+ );
setStatus('validating');
try {
const result = await wsValidateApiKey(provider, apiKey.trim());
+ if (!isCurrent()) return;
if (result.isValid) {
setStatus('valid');
setHasStoredKeyState(true);
toast.success('API key validated successfully!');
- if (result.models?.length && onSuccess) {
- onSuccess(result.models);
+ if (result.models?.length && onSuccessRef.current) {
+ onSuccessRef.current(result.models);
}
} else {
setStatus('invalid');
toast.error(result.error || 'Invalid API key');
}
} catch (error: any) {
- setStatus('invalid');
- toast.error(error.message || 'Validation failed');
+ if (isCurrent()) {
+ setStatus('invalid');
+ toast.error(error.message || 'Validation failed');
+ }
}
- }, [provider, onSuccess, wsValidateApiKey]);
+ }, [provider, requestIdentity, wsValidateApiKey]);
const clear = useCallback(async () => {
- if (!provider) return;
-
+ if (!provider) return false;
+
+ const request = ++requestGeneration.current;
+ const identity = requestIdentity;
+ const isCurrent = () => (
+ request === requestGeneration.current
+ && activeRequestIdentity.current === identity
+ );
try {
await wsRemoveApiKey(provider);
+ if (!isCurrent()) return false;
setHasStoredKeyState(false);
setStatus('idle');
toast.success('API key cleared');
+ return true;
} catch (error) {
- toast.error('Failed to clear API key');
+ if (isCurrent()) {
+ toast.error('Failed to clear API key');
+ }
+ return false;
}
- }, [provider, wsRemoveApiKey]);
+ }, [provider, requestIdentity, wsRemoveApiKey]);
const getStoredKey = useCallback(async () => {
if (!provider) return null;
- return await wsGetStoredApiKey(provider);
- }, [provider, wsGetStoredApiKey]);
+ const identity = requestIdentity;
+ const storedKey = await wsGetStoredApiKey(provider);
+ return activeRequestIdentity.current === identity ? storedKey : null;
+ }, [provider, requestIdentity, wsGetStoredApiKey]);
return {
status,
@@ -104,4 +153,4 @@ export const useApiKeyValidation = ({ provider, onSuccess }: UseApiKeyValidation
isValid: status === 'valid',
isInvalid: status === 'invalid'
};
-};
\ No newline at end of file
+};
diff --git a/client/src/utils/executionResults.ts b/client/src/utils/executionResults.ts
new file mode 100644
index 00000000..aed77434
--- /dev/null
+++ b/client/src/utils/executionResults.ts
@@ -0,0 +1,9 @@
+import type { ExecutionResult } from '../services/executionService';
+
+/** Return the newest result owned by a physical node (inputs are newest-first). */
+export function latestResultForNode(
+ results: ExecutionResult[],
+ nodeId: string,
+): ExecutionResult | undefined {
+ return results.find((result) => result.nodeId === nodeId);
+}
diff --git a/client/src/utils/parameterPanelExecutionState.ts b/client/src/utils/parameterPanelExecutionState.ts
new file mode 100644
index 00000000..2272150c
--- /dev/null
+++ b/client/src/utils/parameterPanelExecutionState.ts
@@ -0,0 +1,37 @@
+import type { ExecutionResult } from '../services/executionService';
+
+export interface NodeExecutionEntry {
+ running: boolean;
+ results: ExecutionResult[];
+}
+
+export type NodeExecutionState = Record<string, NodeExecutionEntry>;
+
+export type NodeExecutionAction =
+ | { type: 'start'; nodeId: string }
+ | { type: 'append'; nodeId: string; result: ExecutionResult }
+ | { type: 'finish'; nodeId: string }
+ | { type: 'clear'; nodeId: string };
+
+export function nodeExecutionReducer(
+ state: NodeExecutionState,
+ action: NodeExecutionAction,
+): NodeExecutionState {
+ const current = state[action.nodeId] ?? { running: false, results: [] };
+ switch (action.type) {
+ case 'start':
+ return { ...state, [action.nodeId]: { ...current, running: true } };
+ case 'append':
+ return {
+ ...state,
+ [action.nodeId]: {
+ running: current.running,
+ results: [action.result, ...current.results],
+ },
+ };
+ case 'finish':
+ return { ...state, [action.nodeId]: { ...current, running: false } };
+ case 'clear':
+ return { ...state, [action.nodeId]: { ...current, results: [] } };
+ }
+}