fix(backend): Complete AI Model Configuration with all 3 endpoints (POST/GET/PUT)

LocalMind-Backend/src/api/v1/AiModelConfig/AiModelConfig.controller.ts

@@ -4,12 +4,10 @@ import UserUtils from '../user/user.utils'
 import { SendResponse } from '../../../utils/SendResponse.utils'
 import { aiModelConfig_Constant } from './AiModelConfig.constant'
 import AiModelConfigService from './AiModelConfig.service'
-import { aiModelConfig_CreateSchema } from './AiModelConfig.validator'
+import { aiModelConfig_CreateSchema, aiModelConfig_UpdateSchema } from './AiModelConfig.validator'
 import { IAgent } from './AiModelConfig.type'
 
 class AiModelConfig_Controller {
-  public async createAiModelConfig(_data: unknown) {}
-
   public async setupAiModelConfig(req: Request, res: Response): Promise<void> {
     try {
       const token = req.headers.authorization?.split(' ')[1] || req.cookies?.token
@@ -31,24 +29,26 @@ class AiModelConfig_Controller {
       if (!existingConfig) {
         CreateConfig = await AiModelConfigService.setupAiModelConfig({
           userId: String(FindUserByToken._id),
-          agents: [{} as IAgent],
+          agents: [],
           system_prompt,
         })
       }
 
-      await Promise.all(
-        (agents as IAgent[]).map(async (agent) => {
-          const isAlreadyAdded = await AiModelConfigUtility.findAiModelConfigById_And_ModelName(
-            String(FindUserByToken._id),
-            agent.model
-          )
-          if (!isAlreadyAdded) {
-            await AiModelConfigService.addAgent(String(FindUserByToken._id), agent)
-          }
-        })
+      // Add agents without duplicates (check in-memory)
+      const existingModels = new Set(
+        (existingConfig?.agents || CreateConfig?.agents || []).map((a: IAgent) => a.model)
       )
 
-      const configToReturn = CreateConfig || existingConfig
+      for (const agent of agents as IAgent[]) {
+        if (!existingModels.has(agent.model)) {
+          await AiModelConfigService.addAgent(String(FindUserByToken._id), agent)
+          existingModels.add(agent.model)
+        }
+      }
+
+      const configToReturn = await AiModelConfigUtility.findAiModelConfigByUserId(
+        String(FindUserByToken._id)
+      )
 
       SendResponse.success(
         res,
@@ -57,8 +57,6 @@ class AiModelConfig_Controller {
         201
       )
     } catch (error) {
-      console.error('Error in setupAiModelConfig:', error)
-
       SendResponse.error(
         res,
         (error as Error).message || 'Failed to set up AI Model Config',
@@ -68,9 +66,100 @@ class AiModelConfig_Controller {
     }
   }
 
-  public async updateAiModelConfig(_data: unknown) {}
+  public async getAiModelConfig(req: Request, res: Response): Promise<void> {
+    try {
+      const userId = (req as any).user?._id || (req as any).user?.id
+
+      if (!userId) {
+        SendResponse.error(res, 'Authentication required', 401, null)
+        return
+      }
+
+      const config = await AiModelConfigService.getConfig(String(userId))
+
+      if (!config) {
+        SendResponse.error(res, 'No AI Model Configuration found', 404, null)
+        return
+      }
+
+      SendResponse.success(res, 'AI Model Configuration retrieved successfully', {
+        config,
+      })
+    } catch (error) {
+      SendResponse.error(
+        res,
+        (error as Error).message || 'Failed to retrieve AI Model Config',
+        500,
+        error
+      )
+    }
+  }
+
+  public async updateAiModelConfig(req: Request, res: Response): Promise<void> {
+    try {
+      const userId = (req as any).user?._id || (req as any).user?.id
+
+      if (!userId) {
+        SendResponse.error(res, 'Authentication required', 401, null)
+        return
+      }
+
+      const ValidateData = await aiModelConfig_UpdateSchema.parseAsync(req.body)
+
+      const updatedConfig = await AiModelConfigService.updateConfig(String(userId), ValidateData)
+
+      if (!updatedConfig) {
+        SendResponse.error(res, 'AI Model Configuration not found', 404, null)
+        return
+      }
+
+      SendResponse.success(res, 'AI Model Configuration updated successfully', {
+        config: updatedConfig,
+      })
+    } catch (error) {
+      if ((error as any).code === 'P2025') {
+        SendResponse.error(res, 'AI Model Configuration not found', 404, null)
+        return
+      }
+
+      SendResponse.error(
+        res,
+        (error as Error).message || 'Failed to update AI Model Config',
+        500,
+        error
+      )
+    }
+  }
+
+  public async removeAgent(req: Request, res: Response): Promise<void> {
+    try {
+      const userId = (req as any).user?._id || (req as any).user?.id
+      const { agentId } = req.params
+
+      if (!userId) {
+        SendResponse.error(res, 'Authentication required', 401, null)
+        return
+      }
 
-  public async deleteAiModelConfig(_data: unknown) {}
+      if (!agentId) {
+        SendResponse.error(res, 'Agent ID is required', 400, null)
+        return
+      }
+
+      const updatedConfig = await AiModelConfigService.removeAgent(String(userId), agentId)
+
+      SendResponse.success(res, 'Agent removed successfully', {
+        config: updatedConfig,
+      })
+    } catch (error) {
+      SendResponse.error(
+        res,
+        (error as Error).message || 'Failed to remove agent',
+        500,
+        error
+      )
+    }
+  }
 }
 
 export default new AiModelConfig_Controller()

LocalMind-Backend/src/api/v1/AiModelConfig/AiModelConfig.routes.ts

@@ -1,7 +1,19 @@
 import { Router } from 'express'
 import AiModelConfigController from './AiModelConfig.controller'
+import { userMiddleware } from '../user/user.middleware'
+
 const router: Router = Router()
 
+// POST: Create/setup AI model config
 router.post('/v1/config/agents', AiModelConfigController.setupAiModelConfig)
 
+// GET: Retrieve AI model config (no plaintext API keys)
+router.get('/v1/get/ai-model-config', userMiddleware, AiModelConfigController.getAiModelConfig)
+
+// PUT: Update AI model config
+router.put('/v1/update/ai-model-config', userMiddleware, AiModelConfigController.updateAiModelConfig)
+
+// DELETE: Remove a specific agent from config
+router.delete('/v1/config/agents/:agentId', userMiddleware, AiModelConfigController.removeAgent)
+
 export { router as AiModelConfigRoutes }

LocalMind-Backend/src/api/v1/AiModelConfig/AiModelConfig.service.ts

@@ -1,4 +1,3 @@
-import { console } from 'inspector'
 import AiModelConfig from './AiModelConfig.model'
 import { IAiModelConfig, IAgent } from './AiModelConfig.type'
 
@@ -8,22 +7,44 @@ class AiModelConfig_Service {
   }
 
   async addAgent(userId: string, agent: IAgent): Promise<IAiModelConfig | null> {
-    console.log('Adding agent for userId:', userId, 'with agent:', agent)
     return await AiModelConfig.findOneAndUpdate(
       { userId },
-      { $push: { agents: agent } },
+      { $addToSet: { agents: agent } },
       { new: true }
     )
   }
 
-  async removeAgent(userId: string, _agentId: string): Promise<IAiModelConfig | null> {
-    const config = (await AiModelConfig.findOne({ userId }).exec()) as any
+  async removeAgent(userId: string, agentId: string): Promise<IAiModelConfig | null> {
+    if (!agentId) {
+      throw new Error('Agent ID is required to remove an agent.')
+    }
+
+    const config = await AiModelConfig.findOneAndUpdate(
+      { userId },
+      { $pull: { agents: { _id: agentId } } },
+      { new: true }
+    ).exec()
 
     if (!config) {
       throw new Error('AI Model Config not found for the user.')
     }
 
-    return await config.save()
+    return config
+  }
+
+  async getConfig(userId: string): Promise<IAiModelConfig | null> {
+    return await AiModelConfig.findOne({ userId }).select('-agents.key').exec()
+  }
+
+  async updateConfig(
+    userId: string,
+    updates: Partial<IAiModelConfig>
+  ): Promise<IAiModelConfig | null> {
+    return await AiModelConfig.findOneAndUpdate({ userId }, updates, {
+      new: true,
+    })
+      .select('-agents.key')
+      .exec()
   }
 }
 

LocalMind-Backend/src/api/v1/AiModelConfig/AiModelConfig.utility.ts

@@ -7,14 +7,14 @@ class AiModelConfigUtility {
   }
 
   public async findAiModelConfigById_And_ModelName(
-    id: string,
+    userId: string,
     modelName: string
   ): Promise<IAiModelConfig | null> {
-    return await AiModelConfig.findOne({ _id: id, 'agents.model': modelName }).exec()
+    return await AiModelConfig.findOne({ userId, 'agents.model': modelName }).exec()
   }
 
-  public async findAiModelConfigByUserId(id: string): Promise<IAiModelConfig | null> {
-    return await AiModelConfig.findById(id).exec()
+  public async findAiModelConfigByUserId(userId: string): Promise<IAiModelConfig | null> {
+    return await AiModelConfig.findOne({ userId }).select('-agents.key').exec()
   }
 
   public async findAiModelConfigsByUserId(userId: string): Promise<IAiModelConfig[]> {