Merge pull request #1779 from ModelEngine-Group/xyc/agent_generate_bugfix

Author: Phinease

frontend/app/[locale]/agents/components/AgentSetupOrchestrator.tsx

@@ -18,7 +18,12 @@ import {
   searchToolConfig,
   updateToolConfig,
 } from "@/services/agentConfigService";
-import { Agent, AgentSetupOrchestratorProps, Tool } from "@/types/agentConfig";
+import {
+  Agent,
+  AgentSetupOrchestratorProps,
+  Tool,
+  ToolParam,
+} from "@/types/agentConfig";
 import log from "@/lib/logger";
 
 import SubAgentPool from "./agent/SubAgentPool";
@@ -90,6 +95,9 @@ export default function AgentSetupOrchestrator({
   const [enabledToolIds, setEnabledToolIds] = useState<number[]>([]);
   const [isLoadingTools, setIsLoadingTools] = useState(false);
   const [isImporting, setIsImporting] = useState(false);
+  const [toolConfigDrafts, setToolConfigDrafts] = useState<
+    Record<string, ToolParam[]>
+  >({});
   // Use generation state passed from parent component, not local state
 
   // Delete confirmation popup status
@@ -146,6 +154,19 @@ export default function AgentSetupOrchestrator({
     []
   );
 
+  const numericMainAgentId =
+    mainAgentId !== null &&
+    mainAgentId !== undefined &&
+    String(mainAgentId).trim() !== ""
+      ? Number(mainAgentId)
+      : null;
+  const hasPersistedMainAgentId =
+    typeof numericMainAgentId === "number" &&
+    !Number.isNaN(numericMainAgentId) &&
+    numericMainAgentId > 0;
+  const isDraftCreationSession =
+    isCreatingNewAgent && !hasPersistedMainAgentId && !isEditingAgent;
+
   // Add a flag to track if it has been initialized to avoid duplicate calls
   const hasInitialized = useRef(false);
   // Baseline snapshot for change detection
@@ -256,6 +277,12 @@ export default function AgentSetupOrchestrator({
     }
   }, [isEditingAgent, editingAgent]);
 
+  useEffect(() => {
+    if (!isDraftCreationSession) {
+      setToolConfigDrafts({});
+    }
+  }, [isDraftCreationSession]);
+
   // Initialize baseline when entering create mode so draft changes don't attach to previous agent
   useEffect(() => {
     if (isCreatingNewAgent && !isEditingAgent) {
@@ -478,6 +505,36 @@ export default function AgentSetupOrchestrator({
     [hasUnsavedChanges]
   );
 
+  const handleToolConfigDraftSave = useCallback(
+    (updatedTool: Tool) => {
+      if (!isDraftCreationSession) {
+        return;
+      }
+      setToolConfigDrafts((prev) => ({
+        ...prev,
+        [updatedTool.id]:
+          updatedTool.initParams?.map((param) => ({ ...param })) || [],
+      }));
+      setSelectedTools((prev: Tool[]) => {
+        if (!prev || prev.length === 0) {
+          return prev;
+        }
+        const index = prev.findIndex((tool) => tool.id === updatedTool.id);
+        if (index === -1) {
+          return prev;
+        }
+        const next = [...prev];
+        next[index] = {
+          ...updatedTool,
+          initParams:
+            updatedTool.initParams?.map((param) => ({ ...param })) || [],
+        };
+        return next;
+      });
+    },
+    [isDraftCreationSession, setSelectedTools]
+  );
+
   // Function to directly update enabledAgentIds
   const handleUpdateEnabledAgentIds = (newEnabledAgentIds: number[]) => {
     setEnabledAgentIds(newEnabledAgentIds);
@@ -512,21 +569,46 @@ export default function AgentSetupOrchestrator({
     }
   }, [isCreatingNewAgent, isEditingAgent, mainAgentId]);
 
+  const applyDraftParamsToTool = useCallback(
+    (tool: Tool): Tool => {
+      if (!isDraftCreationSession) {
+        return tool;
+      }
+      const draft = toolConfigDrafts[tool.id];
+      if (!draft || draft.length === 0) {
+        return tool;
+      }
+      return {
+        ...tool,
+        initParams: draft.map((param) => ({ ...param })),
+      };
+    },
+    [isDraftCreationSession, toolConfigDrafts]
+  );
+
   // Listen for changes in the tool status, update the selected tool
   useEffect(() => {
     if (!tools || isLoadingTools) return;
     // Allow empty enabledToolIds array (it's valid when no tools are selected)
     if (enabledToolIds === undefined || enabledToolIds === null) return;
 
     // Filter out unavailable tools (is_available === false) to prevent deleted MCP tools from showing
-    const enabledTools = tools.filter(
-      (tool) =>
-        enabledToolIds.includes(Number(tool.id)) &&
-        tool.is_available !== false
-    );
+    const enabledTools = tools
+      .filter(
+        (tool) =>
+          enabledToolIds.includes(Number(tool.id)) &&
+          tool.is_available !== false
+      )
+      .map((tool) => applyDraftParamsToTool(tool));
 
     setSelectedTools(enabledTools);
-  }, [tools, enabledToolIds, isLoadingTools]);
+  }, [
+    tools,
+    enabledToolIds,
+    isLoadingTools,
+    applyDraftParamsToTool,
+    setSelectedTools,
+  ]);
 
   // Auto-unselect knowledge_base_search if embedding is not configured
   useEffect(() => {
@@ -913,6 +995,61 @@ export default function AgentSetupOrchestrator({
   };
 
   // Handle the creation of a new Agent
+  const persistDraftToolConfigs = useCallback(
+    async (agentId: number, toolIdsToEnable: number[]) => {
+      if (!toolIdsToEnable || toolIdsToEnable.length === 0) {
+        return;
+      }
+
+      const payloads = toolIdsToEnable
+        .map((toolId) => {
+          const toolIdStr = String(toolId);
+          const draftParams = toolConfigDrafts[toolIdStr];
+          const baseTool =
+            selectedTools.find((tool) => Number(tool.id) === toolId) ||
+            tools.find((tool) => Number(tool.id) === toolId);
+          const paramsSource =
+            (draftParams && draftParams.length > 0
+              ? draftParams
+              : baseTool?.initParams) || [];
+          if (!paramsSource || paramsSource.length === 0) {
+            return null;
+          }
+          const params = paramsSource.reduce((acc, param) => {
+            acc[param.name] = param.value;
+            return acc;
+          }, {} as Record<string, any>);
+          return {
+            toolId,
+            params,
+          };
+        })
+        .filter(Boolean) as Array<{
+        toolId: number;
+        params: Record<string, any>;
+      }>;
+
+      if (payloads.length === 0) {
+        return;
+      }
+
+      let persistError = false;
+      for (const payload of payloads) {
+        try {
+          await updateToolConfig(payload.toolId, agentId, payload.params, true);
+        } catch (error) {
+          persistError = true;
+          log.error("Failed to persist tool configuration for new agent:", error);
+        }
+      }
+
+      if (persistError) {
+        message.error(t("toolConfig.message.saveError"));
+      }
+    },
+    [toolConfigDrafts, selectedTools, tools, message, t]
+  );
+
   const handleSaveNewAgent = async (
     name: string,
     description: string,
@@ -987,6 +1124,13 @@ export default function AgentSetupOrchestrator({
         }
 
         if (result.success) {
+          if (!isEditingAgent && result.data?.agent_id) {
+            await persistDraftToolConfigs(
+              Number(result.data.agent_id),
+              deduplicatedToolIds
+            );
+            setToolConfigDrafts({});
+          }
           // If created, set new mainAgentId for subsequent operations
           if (!isEditingAgent && result.data?.agent_id) {
             setMainAgentId(String(result.data.agent_id));
@@ -1723,6 +1867,8 @@ export default function AgentSetupOrchestrator({
                     isGeneratingAgent={isGeneratingAgent}
                     isEmbeddingConfigured={isEmbeddingConfigured}
                     agentUnavailableReasons={agentUnavailableReasons}
+                    onToolConfigSave={handleToolConfigDraftSave}
+                    toolConfigDrafts={toolConfigDrafts}
                   />
                 </div>
               </div>

frontend/app/[locale]/agents/components/tool/ToolConfigModal.tsx

@@ -63,6 +63,13 @@ export default function ToolConfigModal({
   const { windowWidth, mainModalTop, mainModalRight } =
     useModalPosition(isOpen);
 
+  const normalizedAgentId =
+    typeof mainAgentId === "number" && !Number.isNaN(mainAgentId)
+      ? mainAgentId
+      : null;
+  const canPersistToolConfig =
+    typeof normalizedAgentId === "number" && normalizedAgentId > 0;
+
   // load tool config
   useEffect(() => {
     const buildDefaultParams = () =>
@@ -78,14 +85,17 @@ export default function ToolConfigModal({
       }
 
       // In creation mode we do not have an agent ID yet, so use the tool's default params.
-      if (!mainAgentId) {
+      if (!normalizedAgentId) {
         setCurrentParams(buildDefaultParams());
         return;
       }
 
       setIsLoading(true);
       try {
-        const result = await searchToolConfig(parseInt(tool.id), mainAgentId);
+        const result = await searchToolConfig(
+          parseInt(tool.id),
+          normalizedAgentId
+        );
         if (result.success) {
           if (result.data?.params) {
             const savedParams = tool.initParams.map((param) => {
@@ -117,7 +127,7 @@ export default function ToolConfigModal({
     } else {
       setCurrentParams([]);
     }
-  }, [isOpen, tool, mainAgentId, t, message]);
+  }, [isOpen, tool, normalizedAgentId, t, message]);
 
   // check required fields
   const checkRequiredFields = () => {
@@ -190,12 +200,21 @@ export default function ToolConfigModal({
         return acc;
       }, {} as Record<string, any>);
 
+      if (!canPersistToolConfig) {
+        message.success(t("toolConfig.message.saveSuccess"));
+        onSave({
+          ...tool,
+          initParams: currentParams,
+        });
+        return;
+      }
+
       // decide enabled status based on whether the tool is in selectedTools
       const isEnabled = selectedTools.some((t) => t.id === tool.id);
 
       const result = await updateToolConfig(
         parseInt(tool.id),
-        mainAgentId,
+        normalizedAgentId,
         params,
         isEnabled
       );