11720985132

Committed 07 Nov 2024 10:17AM UTC coverage: 95.829% (-0.6%) from 96.43%

Build # 11720985132

Build Type

push

github

Committed by

lazToum

Commit Message

fix: modals: close and cancel

Run Details

2114 of 2325 branches covered (90.92%)

Branch coverage included in aggregate %.

4 of 5 new or added lines in 4 files covered. (80.0%)

158 existing lines in 11 files now uncovered.

12499 of 12924 relevant lines covered (96.71%)

469.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.09

/src/waldiez/components/nodes/agent/index.tsx

import { Connection, NodeProps } from '@xyflow/react';

import { useEffect, useState } from 'react';

import { WaldiezNodeAgentView } from '@waldiez/components/nodes/agent/view';
import {
  WaldiezAgentNode,
  WaldiezAgentNodeData,
  WaldiezAgentNodeType,
  WaldiezEdge,
  WaldiezModelNode,
  WaldiezNodeRagUserData,
  WaldiezNodeUserOrAssistantData,
  WaldiezSkillNode,
  defaultRetrieveConfig
} from '@waldiez/models';
import { useWaldiezContext } from '@waldiez/store';
import { isDarkMode } from '@waldiez/theme';

export const WaldiezNodeAgent = ({ id, data, parentId }: NodeProps<WaldiezAgentNode>) => {
  const updateAgentData = useWaldiezContext(s => s.updateAgentData);
  const addEdge = useWaldiezContext(s => s.addEdge);
  const cloneAgent = useWaldiezContext(s => s.cloneAgent);
  const getAgentById = useWaldiezContext(s => s.getAgentById);
  const getEdgeById = useWaldiezContext(s => s.getEdgeById);
  const uploadHandler = useWaldiezContext(s => s.onUpload);
  const deleteAgent = useWaldiezContext(s => s.deleteAgent);
  const getAgentConnections = useWaldiezContext(s => s.getAgentConnections);
  const removeGroupMember = useWaldiezContext(s => s.removeGroupMember);
  const addGroupMember = useWaldiezContext(s => s.addGroupMember);
  const changeGroup = useWaldiezContext(s => s.changeGroup);
  const updateEdgePath = useWaldiezContext(s => s.updateEdgePath);
  const reselectNode = useWaldiezContext(s => s.reselectNode);
  const getSkills = useWaldiezContext(s => s.getSkills);
  const getModels = useWaldiezContext(s => s.getModels);
  const getAgents = useWaldiezContext(s => s.getAgents);
  const flowId = useWaldiezContext(s => s.flowId);
  const storageId = useWaldiezContext(s => s.storageId);
  // tmp state, persist on submit, discard on cancel
  const [agentData, setAgentData] = useState<WaldiezAgentNodeData>({ ...data });
  const [isDirty, setIsDirty] = useState(false);
  const [isNodeModalOpen, setNodeModalOpen] = useState(false);
  const [isEdgeModalOpen, setEdgeModalOpen] = useState(false);
  const [edge, setEdge] = useState<WaldiezEdge | null>(null);
  const currentStoredGroupManager = parentId ? getAgentById(parentId) : null;
  const [currentGroupManager, setCurrentGroupManager] = useState<WaldiezAgentNode | null>(
    currentStoredGroupManager as WaldiezAgentNode
  );
  useEffect(() => {
    setCurrentGroupManager(parentId ? (getAgentById(parentId) as WaldiezAgentNode) : null);
  }, [parentId]);
  useEffect(() => {
    setAgentData({ ...data });
  }, [data]);
  const onOpenNodeModal = () => {
    if (!isEdgeModalOpen && !isNodeModalOpen) {
      setNodeModalOpen(true);
    }
  };
  const onOpenEdgeModal = (event: React.MouseEvent) => {
    if (!isNodeModalOpen && !isEdgeModalOpen) {
      const dataEdgeId = event.currentTarget.getAttribute('data-edge-id');
      if (dataEdgeId) {
        const existingEdge = getEdgeById(dataEdgeId);
        if (existingEdge) {
          setEdge(existingEdge as WaldiezEdge);
          setEdgeModalOpen(true);
        }
      }
    }
  };
  const onCloseEdgeModal = () => {
    setEdgeModalOpen(false);
    setEdge(null);
  };
  const onEdgeConnection = (connection: Connection) => {
    if (!isNodeModalOpen) {
      const newEdge = addEdge(connection.source, connection.target, false);
      setEdge(newEdge as WaldiezEdge);
      // setEdgeModalOpen(true);
    }
  };
  const setManagerState = (partialData: Partial<WaldiezAgentNodeData>) => {
    setAgentData({ ...agentData, ...partialData, nestedChats: [] });
    setIsDirty(JSON.stringify({ ...agentData, ...partialData }) !== JSON.stringify(data));
  };
  const setNoManagerState = (partialData: Partial<WaldiezAgentNodeData>) => {
    const newData = partialData as WaldiezNodeUserOrAssistantData;
    let nestedChats = (agentData as WaldiezNodeUserOrAssistantData).nestedChats;
    if (newData.nestedChats) {
      nestedChats = newData.nestedChats;
    }
    const dataToSet = { ...agentData, ...newData, nestedChats };
    setAgentData(dataToSet);
    setIsDirty(JSON.stringify(dataToSet) !== JSON.stringify(data));
  };

  const setAgentState = (partialData: Partial<WaldiezAgentNodeData>, persist: boolean = false) => {
    const isManager = agentData.agentType === 'manager';
    if (isManager) {
      setManagerState(partialData);
    } else {
      setNoManagerState(partialData);
    }
    if (persist === true) {
      updateAgentData(id, partialData);
      setIsDirty(false);
    }
  };
  const toRagUser = () => {
    // make sure data.retrieveConfig (WaldiezRageUserRetrieveConfig) is set
    const ragData = agentData as { [key: string]: any };
    ragData.agentType = 'rag_user';
    if (!ragData.retrieveConfig) {
      ragData.retrieveConfig = defaultRetrieveConfig;
    }
    setAgentData({
      ...agentData,
      ...ragData
    });
  };
  const toUser = () => {
    // remove retrieveConfig if it exists
    const noRagData = agentData as { [key: string]: any };
    noRagData.agentType = 'user';
    if (noRagData.retrieveConfig) {
      delete noRagData.retrieveConfig;
    }
    setAgentData({
      ...agentData,
      ...noRagData
    });
  };

  const onAgentTypeChange = (agentType: WaldiezAgentNodeType) => {
    // rag_user | user only
    if (agentType === 'rag_user') {
      toRagUser();
    } else {
      toUser();
    }
    setIsDirty(data.agentType !== agentType);
  };
  const onClone = () => {
    cloneAgent(id);
  };
  const onDelete = () => {
    deleteAgent(id);
  };
  const updateAgentConnections = (newAgentType: WaldiezAgentNodeType) => {
    const agentConnections = getAgentConnections(id, {
      sourcesOnly: true
    });
    agentConnections.target.edges.forEach(edge => {
      updateEdgePath(edge.id, newAgentType);
    });
  };
  const handleAgentTypeChange = (dataToSubmit: { [key: string]: any }) => {
    const newAgentType = dataToSubmit.agentType as WaldiezAgentNodeType;
    updateAgentConnections(newAgentType);
    if (newAgentType === 'rag_user' && !dataToSubmit.retrieveConfig) {
      dataToSubmit.retrieveConfig = defaultRetrieveConfig;
    } else if (newAgentType === 'user' && dataToSubmit.retrieveConfig) {
      delete dataToSubmit.retrieveConfig;
    }
    return dataToSubmit;
  };
  const postSubmit = () => {
    const storedAgent = getAgentById(id);
    if (!storedAgent) {
      return;
    }
    if (storedAgent.data) {
      setAgentData({ ...(storedAgent.data as WaldiezAgentNodeData) });
      setIsDirty(false);
    }
    // setNodeModalOpen(false);
  };
  const submit = (dataToSubmit: { [key: string]: any }) => {
    if (dataToSubmit.agentType !== data.agentType) {
      dataToSubmit = handleAgentTypeChange(dataToSubmit);
    }
    updateAgentData(id, dataToSubmit);
    handleGroupChange();
    if (parentId) {
      reselectNode(parentId);
    } else if (currentGroupManager) {
      reselectNode(currentGroupManager.id);
    }
    // update the group state
    if (!parentId && currentGroupManager) {
      setCurrentGroupManager(getAgentById(currentGroupManager.id) as WaldiezAgentNode);
    } else if (!currentGroupManager) {
      setCurrentGroupManager(null);
    }
    postSubmit();
  };
  const handleGroupChange = () => {
    if (!parentId && currentGroupManager) {
      // join the group
      addGroupMember(currentGroupManager.id, id);
    } else if (parentId && !currentGroupManager) {
      // leave the group
      removeGroupMember(parentId, id);
    } else if (parentId && currentGroupManager && currentGroupManager.id !== parentId) {
      // change the group
      changeGroup(id, currentGroupManager.id);
    }
  };
  const onSave = (filesToUpload: File[]) => {
    const dataToSubmit = { ...agentData } as { [key: string]: any };
    if (agentData.agentType === 'rag_user' && filesToUpload.length > 0 && uploadHandler) {
      uploadHandler(filesToUpload).then(filePaths => {
        const ragData = agentData as WaldiezNodeRagUserData;
        const docsPath = ragData.retrieveConfig.docsPath;
        const newDocsPath = [...docsPath];
        for (let i = 0; i < filesToUpload.length; i++) {
          const index = newDocsPath.indexOf(`file:///${filesToUpload[i].name}`);
          if (index > -1) {
            newDocsPath[index] = filePaths[i];
          }
        }
        dataToSubmit.retrieveConfig.docsPath = newDocsPath;
        submit(dataToSubmit);
      });
    } else {
      submit(dataToSubmit);
    }
  };
  const onCancel = () => {
    const storedAgent = getAgentById(id);
    if (!storedAgent) {
      setNodeModalOpen(false);
      return;
    }
    if (storedAgent.data) {
      setAgentData({ ...(storedAgent.data as WaldiezAgentNodeData) });
    }
    setCurrentGroupManager(parentId ? (getAgentById(parentId) as WaldiezAgentNode) : null);
    setNodeModalOpen(false);
  };
  const skills = getSkills() as WaldiezSkillNode[];
  const models = getModels() as WaldiezModelNode[];
  const agents = getAgents() as WaldiezAgentNode[];
  const agentConnections = getAgentConnections(id);
  const isDark = isDarkMode(flowId, storageId ?? flowId);
  const uploadsEnabled = uploadHandler !== null;
  return (
    <WaldiezNodeAgentView
      id={id}
      flowId={flowId}
      data={agentData}
      isDirty={isDirty}
      skills={skills}
      models={models}
      agents={agents}
      agentConnections={agentConnections}
      uploadsEnabled={uploadsEnabled}
      parentId={parentId}
      edge={edge}
      isNodeModalOpen={isNodeModalOpen}
      isEdgeModalOpen={isEdgeModalOpen}
      isDarkMode={isDark}
      currentGroupManager={currentGroupManager}
      setCurrentGroupManager={setCurrentGroupManager}
      onDataChange={setAgentState}
      onOpenNodeModal={onOpenNodeModal}
      onOpenEdgeModal={onOpenEdgeModal}
      onCloseNodeModal={onCancel}
      onCloseEdgeModal={onCloseEdgeModal}
      onEdgeConnection={onEdgeConnection}
      onAgentTypeChange={onAgentTypeChange}
      onClone={onClone}
      onDelete={onDelete}
      onSave={onSave}
      onCancel={onCancel}
    />
  );
};

1	import { Connection, NodeProps } from '@xyflow/react';	1✔
2
3	import { useEffect, useState } from 'react';
4
5	import { WaldiezNodeAgentView } from '@waldiez/components/nodes/agent/view';
6	import {
7	WaldiezAgentNode,
8	WaldiezAgentNodeData,
9	WaldiezAgentNodeType,
10	WaldiezEdge,
11	WaldiezModelNode,
12	WaldiezNodeRagUserData,
13	WaldiezNodeUserOrAssistantData,
14	WaldiezSkillNode,
15	defaultRetrieveConfig
16	} from '@waldiez/models';
17	import { useWaldiezContext } from '@waldiez/store';
18	import { isDarkMode } from '@waldiez/theme';
19
20	export const WaldiezNodeAgent = ({ id, data, parentId }: NodeProps<WaldiezAgentNode>) => {	1✔
21	const updateAgentData = useWaldiezContext(s => s.updateAgentData);	4,190✔
22	const addEdge = useWaldiezContext(s => s.addEdge);	4,190✔
23	const cloneAgent = useWaldiezContext(s => s.cloneAgent);	4,190✔
24	const getAgentById = useWaldiezContext(s => s.getAgentById);	4,190✔
25	const getEdgeById = useWaldiezContext(s => s.getEdgeById);	4,190✔
26	const uploadHandler = useWaldiezContext(s => s.onUpload);	4,190✔
27	const deleteAgent = useWaldiezContext(s => s.deleteAgent);	4,190✔
28	const getAgentConnections = useWaldiezContext(s => s.getAgentConnections);	4,190✔
29	const removeGroupMember = useWaldiezContext(s => s.removeGroupMember);	4,190✔
30	const addGroupMember = useWaldiezContext(s => s.addGroupMember);	4,190✔
31	const changeGroup = useWaldiezContext(s => s.changeGroup);	4,190✔
32	const updateEdgePath = useWaldiezContext(s => s.updateEdgePath);	4,190✔
33	const reselectNode = useWaldiezContext(s => s.reselectNode);	4,190✔
34	const getSkills = useWaldiezContext(s => s.getSkills);	4,190✔
35	const getModels = useWaldiezContext(s => s.getModels);	4,190✔
36	const getAgents = useWaldiezContext(s => s.getAgents);	4,190✔
37	const flowId = useWaldiezContext(s => s.flowId);	4,190✔
38	const storageId = useWaldiezContext(s => s.storageId);	4,190✔
39	// tmp state, persist on submit, discard on cancel
40	const [agentData, setAgentData] = useState<WaldiezAgentNodeData>({ ...data });	4,190✔
41	const [isDirty, setIsDirty] = useState(false);	4,190✔
42	const [isNodeModalOpen, setNodeModalOpen] = useState(false);	4,190✔
43	const [isEdgeModalOpen, setEdgeModalOpen] = useState(false);	4,190✔
44	const [edge, setEdge] = useState<WaldiezEdge \| null>(null);	4,190✔
45	const currentStoredGroupManager = parentId ? getAgentById(parentId) : null;	4,190✔
46	const [currentGroupManager, setCurrentGroupManager] = useState<WaldiezAgentNode \| null>(	4,190✔
47	currentStoredGroupManager as WaldiezAgentNode	4,190✔
48	);	4,190✔
49	useEffect(() => {	4,190✔
50	setCurrentGroupManager(parentId ? (getAgentById(parentId) as WaldiezAgentNode) : null);	609✔
51	}, [parentId]);	4,190✔
52	useEffect(() => {	4,190✔
53	setAgentData({ ...data });	627✔
54	}, [data]);	4,190✔
55	const onOpenNodeModal = () => {	4,190✔
56	if (!isEdgeModalOpen && !isNodeModalOpen) {	123✔
57	setNodeModalOpen(true);	123✔
58	}	123✔
59	};	123✔
60	const onOpenEdgeModal = (event: React.MouseEvent) => {	4,190✔
61	if (!isNodeModalOpen && !isEdgeModalOpen) {	48✔
62	const dataEdgeId = event.currentTarget.getAttribute('data-edge-id');	40✔
63	if (dataEdgeId) {	40✔
64	const existingEdge = getEdgeById(dataEdgeId);	40✔
65	if (existingEdge) {	40✔
66	setEdge(existingEdge as WaldiezEdge);	40✔
67	setEdgeModalOpen(true);	40✔
68	}	40✔
69	}	40✔
70	}	40✔
71	};	48✔
72	const onCloseEdgeModal = () => {	4,190✔
73	setEdgeModalOpen(false);	1✔
74	setEdge(null);	1✔
75	};	1✔
76	const onEdgeConnection = (connection: Connection) => {	4,190✔
77	if (!isNodeModalOpen) {	1✔
78	const newEdge = addEdge(connection.source, connection.target, false);	1✔
79	setEdge(newEdge as WaldiezEdge);	1✔
80	// setEdgeModalOpen(true);
81	}	1✔
82	};	1✔
83	const setManagerState = (partialData: Partial<WaldiezAgentNodeData>) => {	4,190✔
84	setAgentData({ ...agentData, ...partialData, nestedChats: [] });	54✔
85	setIsDirty(JSON.stringify({ ...agentData, ...partialData }) !== JSON.stringify(data));	54✔
86	};	54✔
87	const setNoManagerState = (partialData: Partial<WaldiezAgentNodeData>) => {	4,190✔
88	const newData = partialData as WaldiezNodeUserOrAssistantData;	170✔
89	let nestedChats = (agentData as WaldiezNodeUserOrAssistantData).nestedChats;	170✔
90	if (newData.nestedChats) {	170✔
91	nestedChats = newData.nestedChats;	61✔
92	}	61✔
93	const dataToSet = { ...agentData, ...newData, nestedChats };	170✔
94	setAgentData(dataToSet);	170✔
95	setIsDirty(JSON.stringify(dataToSet) !== JSON.stringify(data));	170✔
96	};	170✔
97
98	const setAgentState = (partialData: Partial<WaldiezAgentNodeData>, persist: boolean = false) => {	4,190✔
99	const isManager = agentData.agentType === 'manager';	224✔
100	if (isManager) {	224✔
101	setManagerState(partialData);	54✔
102	} else {	223✔
103	setNoManagerState(partialData);	170✔
104	}	170✔
105	if (persist === true) {	224✔
106	updateAgentData(id, partialData);	1✔
107	setIsDirty(false);	1✔
108	}	1✔
109	};	224✔
110	const toRagUser = () => {	4,190✔
111	// make sure data.retrieveConfig (WaldiezRageUserRetrieveConfig) is set
112	const ragData = agentData as { [key: string]: any };	1✔
113	ragData.agentType = 'rag_user';	1✔
114	if (!ragData.retrieveConfig) {	1✔
115	ragData.retrieveConfig = defaultRetrieveConfig;	1✔
116	}	1✔
117	setAgentData({	1✔
118	...agentData,	1✔
119	...ragData	1✔
120	});	1✔
121	};	1✔
122	const toUser = () => {	4,190✔
123	// remove retrieveConfig if it exists
124	const noRagData = agentData as { [key: string]: any };	1✔
125	noRagData.agentType = 'user';	1✔
126	if (noRagData.retrieveConfig) {	1✔
127	delete noRagData.retrieveConfig;	1✔
128	}	1✔
129	setAgentData({	1✔
130	...agentData,	1✔
131	...noRagData	1✔
132	});	1✔
133	};	1✔
134
135	const onAgentTypeChange = (agentType: WaldiezAgentNodeType) => {	4,190✔
136	// rag_user \| user only
137	if (agentType === 'rag_user') {	2✔
138	toRagUser();	1✔
139	} else {	1✔
140	toUser();	1✔
141	}	1✔
142	setIsDirty(data.agentType !== agentType);	2✔
143	};	2✔
144	const onClone = () => {	4,190✔
145	cloneAgent(id);	3✔
146	};	3✔
147	const onDelete = () => {	4,190✔
148	deleteAgent(id);	2✔
149	};	2✔
150	const updateAgentConnections = (newAgentType: WaldiezAgentNodeType) => {	4,190✔
151	const agentConnections = getAgentConnections(id, {	6✔
152	sourcesOnly: true	6✔
153	});	6✔
154	agentConnections.target.edges.forEach(edge => {	6✔
UNCOV 155	updateEdgePath(edge.id, newAgentType);	×
156	});	6✔
157	};	6✔
158	const handleAgentTypeChange = (dataToSubmit: { [key: string]: any }) => {	4,190✔
159	const newAgentType = dataToSubmit.agentType as WaldiezAgentNodeType;	6✔
160	updateAgentConnections(newAgentType);	6✔
161	if (newAgentType === 'rag_user' && !dataToSubmit.retrieveConfig) {	6!
UNCOV 162	dataToSubmit.retrieveConfig = defaultRetrieveConfig;	×
163	} else if (newAgentType === 'user' && dataToSubmit.retrieveConfig) {	6!
UNCOV 164	delete dataToSubmit.retrieveConfig;	×
UNCOV 165	}	×
166	return dataToSubmit;	6✔
167	};	6✔
168	const postSubmit = () => {	4,190✔
169	const storedAgent = getAgentById(id);	82✔
170	if (!storedAgent) {	82!
UNCOV 171	return;	×
UNCOV 172	}	×
173	if (storedAgent.data) {	82✔
174	setAgentData({ ...(storedAgent.data as WaldiezAgentNodeData) });	82✔
175	setIsDirty(false);	82✔
176	}	82✔
177	// setNodeModalOpen(false);
178	};	82✔
179	const submit = (dataToSubmit: { [key: string]: any }) => {	4,190✔
180	if (dataToSubmit.agentType !== data.agentType) {	82✔
181	dataToSubmit = handleAgentTypeChange(dataToSubmit);	6✔
182	}	6✔
183	updateAgentData(id, dataToSubmit);	82✔
184	handleGroupChange();	82✔
185	if (parentId) {	82!
186	reselectNode(parentId);	×
187	} else if (currentGroupManager) {	82!
UNCOV 188	reselectNode(currentGroupManager.id);	×
UNCOV 189	}	×
190	// update the group state
191	if (!parentId && currentGroupManager) {	82!
UNCOV 192	setCurrentGroupManager(getAgentById(currentGroupManager.id) as WaldiezAgentNode);	×
193	} else if (!currentGroupManager) {	82✔
194	setCurrentGroupManager(null);	82✔
195	}	82✔
196	postSubmit();	82✔
197	};	82✔
198	const handleGroupChange = () => {	4,190✔
199	if (!parentId && currentGroupManager) {	82!
200	// join the group
UNCOV 201	addGroupMember(currentGroupManager.id, id);	×
202	} else if (parentId && !currentGroupManager) {	82!
203	// leave the group
UNCOV 204	removeGroupMember(parentId, id);	×
205	} else if (parentId && currentGroupManager && currentGroupManager.id !== parentId) {	82!
206	// change the group
UNCOV 207	changeGroup(id, currentGroupManager.id);	×
UNCOV 208	}	×
209	};	82✔
210	const onSave = (filesToUpload: File[]) => {	4,190✔
211	const dataToSubmit = { ...agentData } as { [key: string]: any };	82✔
212	if (agentData.agentType === 'rag_user' && filesToUpload.length > 0 && uploadHandler) {	82✔
213	uploadHandler(filesToUpload).then(filePaths => {	1✔
214	const ragData = agentData as WaldiezNodeRagUserData;	1✔
215	const docsPath = ragData.retrieveConfig.docsPath;	1✔
216	const newDocsPath = [...docsPath];	1✔
217	for (let i = 0; i < filesToUpload.length; i++) {	1✔
218	const index = newDocsPath.indexOf(`file:///${filesToUpload[i].name}`);	1✔
219	if (index > -1) {	1✔
220	newDocsPath[index] = filePaths[i];	1✔
221	}	1✔
222	}	1✔
223	dataToSubmit.retrieveConfig.docsPath = newDocsPath;	1✔
224	submit(dataToSubmit);	1✔
225	});	1✔
226	} else {	82✔
227	submit(dataToSubmit);	81✔
228	}	81✔
229	};	82✔
230	const onCancel = () => {	4,190✔
231	const storedAgent = getAgentById(id);	×
232	if (!storedAgent) {	×
NEW 233	setNodeModalOpen(false);	×
234	return;	×
235	}	×
236	if (storedAgent.data) {	×
237	setAgentData({ ...(storedAgent.data as WaldiezAgentNodeData) });	×
238	}	×
239	setCurrentGroupManager(parentId ? (getAgentById(parentId) as WaldiezAgentNode) : null);	×
240	setNodeModalOpen(false);	×
UNCOV 241	};	×
242	const skills = getSkills() as WaldiezSkillNode[];	4,190✔
243	const models = getModels() as WaldiezModelNode[];	4,190✔
244	const agents = getAgents() as WaldiezAgentNode[];	4,190✔
245	const agentConnections = getAgentConnections(id);	4,190✔
246	const isDark = isDarkMode(flowId, storageId ?? flowId);	4,190!
247	const uploadsEnabled = uploadHandler !== null;	4,190✔
248	return (	4,190✔
249	<WaldiezNodeAgentView	4,190✔
250	id={id}	4,190✔
251	flowId={flowId}	4,190✔
252	data={agentData}	4,190✔
253	isDirty={isDirty}	4,190✔
254	skills={skills}	4,190✔
255	models={models}	4,190✔
256	agents={agents}	4,190✔
257	agentConnections={agentConnections}	4,190✔
258	uploadsEnabled={uploadsEnabled}	4,190✔
259	parentId={parentId}	4,190✔
260	edge={edge}	4,190✔
261	isNodeModalOpen={isNodeModalOpen}	4,190✔
262	isEdgeModalOpen={isEdgeModalOpen}	4,190✔
263	isDarkMode={isDark}	4,190✔
264	currentGroupManager={currentGroupManager}	4,190✔
265	setCurrentGroupManager={setCurrentGroupManager}	4,190✔
266	onDataChange={setAgentState}	4,190✔
267	onOpenNodeModal={onOpenNodeModal}	4,190✔
268	onOpenEdgeModal={onOpenEdgeModal}	4,190✔
269	onCloseNodeModal={onCancel}	4,190✔
270	onCloseEdgeModal={onCloseEdgeModal}	4,190✔
271	onEdgeConnection={onEdgeConnection}	4,190✔
272	onAgentTypeChange={onAgentTypeChange}	4,190✔
273	onClone={onClone}	4,190✔
274	onDelete={onDelete}	4,190✔
275	onSave={onSave}	4,190✔
276	onCancel={onCancel}	4,190✔
277	/>	4,190✔
278	);
279	};	4,190✔

waldiez / react / 11720985132

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous